当我们需要执行同时执行多任务时，一般情况下我们会考虑多线程。

Python标准库提供了两个模块：_thread和threading，而threading是对_thread的封装。绝大多数下我们都会使用threading模块。

下面是一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import threading
import time

def text(n):
    assert isinstance(n ,int)
    assert n > 0
    print('thread %s is running' % threading.current_thread().name)
    for i in range(n):
        print('thread %s --> %s' % (threading.current_thread().name, i))
        time.sleep(1)
    print('thread %s end.' % threading.current_thread().name)
        
print('thread %s is running' % threading.current_thread().name)
t = threading.Thread(target=text, args=(5,), name='ChildThread')
t.start()
t.join()
print('thread %s end.' % threading.current_thread().name)

执行结果如下：

1
2
3
4
5
6
7
8
9
thread MainThread is running
thread ChildThread is running
thread ChildThread --> 0
thread ChildThread --> 1
thread ChildThread --> 2
thread ChildThread --> 3
thread ChildThread --> 4
thread ChildThread end.
thread MainThread end.

Lock

对于多线程来说，往往有个弊端：所有变量都是由所有线程共享的，所以任何一个变量都可以被任何一个线程修改，如果同一时间修改同一变量，结果就会混乱。如下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import threading
import time

bank_money = 0

def change_money(count):
    global bank_money
    bank_money = bank_money + count
    bank_money = bank_money - count
    
def do_num(count):
    for i in range(100000):
        change_money(count)
        
t1 = threading.Thread(target=do_num, args(100,))
t2 = threading.Thread(target=do_num, args(84,))
t1.start()
t2.start()
t1.join()
t2.join()
print(bank_money)

这个例子不是很恰当，但是它能很好的表达出多线程的这种弊端：当t1和t2两个线程交替执行是，只要循环次数足够多，最终bank_money的结果不一定是0了。

为了解决这个问题我们要给change_money()加锁：当某个线程开始执行change_money()时，该线程即获得了锁，其他线程只能等待该线程执行完后，释放锁之后才能执行change_money()函数，这样就不会造成冲突。实例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bank_money = 0
lock = threading.Lock()
  
def do_num(count):
    for i in range(100000):
        # 获取锁
        locak.acquire()
        try:
            change_money(count)
        except:
            # 异常处理
            pass
        finally:
            # 释放锁
            lock.release()

do_num()函数进行了以上更改，其他代码不变，这样执行最终结果扔会是0。需要注意的是，锁一定要释放，否则程序会进行不下去。

锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行，坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。

题外话

Python的线程虽然是真正的线程，但解释器执行代码时，有一个GIL锁：Global Interpreter Lock，任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在Python中只能交替执行，即使100个线程跑在100核CPU上，也只能用到1个核。

GIL是Python解释器设计的历史遗留问题，通常我们用的解释器是官方实现的CPython，要真正利用多核，除非重写一个不带GIL的解释器。

所以，在Python中，可以使用多线程，但不要指望能有效利用多核。如果一定要通过多线程利用多核，那只能通过C扩展来实现，不过这样就失去了Python简单易用的特点。

不过，也不用过于担心，Python虽然不能利用多线程实现多核任务，但可以通过多进程实现多核任务。多个Python进程有各自独立的GIL锁，互不影响。

参考资料 多线程-廖雪峰的官方网站