python多线程

python中创建多线程方法有两种，这里只介绍简单的一种:

from threading import Thread #导入模块

import time

def test(thread_num): #线程需要执行的函数

print('线程%d:aaaaaaa' % thread_num)

time.sleep(2)

print('线程%d:bbbbbbb' % thread_num )

time.sleep(2)

print('线程%d:ccccccc' % thread_num)

if __name__ == '__main__':

print('主线程开启...')

#创建线程，target表示线程需要执行的函数，args表示函数的参数，必须是元组形式

t1 = Thread(target=test, args=(1,))

t2 = Thread(target=test, args=(2,))

t1.start() #线程t1就绪

t2.start() #线程t2就绪

t1.join()#主线程等待线程t1结束

t2.join() #主线程等待线程t2结束

print('主线程结束...')

这是运行两次的结果：

执行

start

方法后，表明线程以准备就绪，但还没开始执行，具体什么时间执行由cpu决定。

可以看到，打印

ccccccc

的时候，第一次是线程2先执行，第二次是线程1先执行，实际上这是随机的，是由操作系统自己决定哪个线程先执行的。

线程锁

当多个线程同时对某个数据进行修改的时候，就会导致数据结果与预期不符，例如，

from threading import Thread

money = 0

def change_money(n=300000):

global money

for i in range(n): #进行30万次 +1 操作

money += 1

t1 = Thread(target=change_money, args=())

t2 = Thread(target=change_money, args=())

if __name == '__main__':

t1.start()

t2.start()

t1.join()

t2.join()

print('money:',money)

该程序即是对

money

全局变量进行30万次 +1 操作，由于是有2个线程，按道理总共是操作了60万次，因此结果应该是

600000

，但是，运行3次的输出却是：

明显与预期不符，为什么会这样，因为

money += 1

这条语句在程序执行起来实际上是有2步操作的，第一步是

计算

money + 1

，第二步是把计算的结果

赋值

给变量

money

。

然而，当我们开启了多个线程后，可能某个线程只执行了第一步，还未执行第二步，数据就被另一个线程拿去使用了。如果这些线程执行的次数很少，可能不会出问题，但是执行几十万、几百万次这种操作时，就会出现这样的状况。

因此为了避免这种状况发生，可以给数据上锁，将数据锁起来，由于锁只有一个，某个线程获得了锁后，另一个线程就必须等待这个线程把锁释放，然后所有线程公平竞争获取这个锁。线程获得锁后，在释放锁前把计算和赋值这两步操作都执行了，这样就不会出错了。

例如：

from threading import Thread, Lock

money = 0

def change_money(n=500000):

global money

for i in range(n):

lock.acquire() #获得锁

money += 1

lock.release() #操作完成，释放锁

t1 = Thread(target=change_money, args=())

t2 = Thread(target=change_money, args=())

lock = Lock() #首先创建锁

t1.start()

t2.start()

t1.join()

t2.join()

print('money:',money)

这是运行3次的结果：

可以看到，没有出错。

时间问题

假设对

money

执行 6 次 +1 操作，每操作一次等待 2 秒，最后共耗费多少时间？

在没学过线程之前，也就是执行时只采用一个线程，按道理最后耗时大概是

12秒

，实际上也是这样，此处不再写代码了，可以自己试一下。

学了多线程后，可以采用2个线程，每个线程操作 3 次，理论上耗时

6秒

，看下这个代码：

from threading import Thread, Lock

import time

money = 0

def change_money(n=3):

global money

for i in range(n):

lock.acquire()

money += 1

time.sleep(2) #等待2秒

lock.release()

t1 = Thread(target=change_money, args=())

t2 = Thread(target=change_money, args=())

lock = Lock()

time1 = time.time()

t1.start()

t2.start()

t1.join()

t2.join()

time2 = time.time()

print('money:',money)

print('耗时：{}'.format(time2 - time1))

输出耗时12秒，怎么回事，不急，再看下面这个代码(在上面这个代码基础上稍微改动一下)：

from threading import Thread, Lock

import time

money = 0

def change_money(n=3):

global money

for i in range(n):

lock.acquire()

money += 1

lock.release()

time.sleep(2) #等待2秒

t1 = Thread(target=change_money, args=())

t2 = Thread(target=change_money, args=())

lock = Lock()

time1 = time.time()

t1.start()

t2.start()

t1.join()

t2.join()

time2 = time.time()

print('money:',money)

print('耗时：{}'.format(time2 - time1))

这时输出为

6秒

， 倒是跟理论值符合。比较这两个代码，只有 11和12行有改动，第一个是先等待2秒，再释放锁；第二个是先释放锁，再等待2秒，问题关键就在于这个锁。

因为锁只有一个，锁在释放前其他所有未获得锁的线程都会等待锁的释放，即锁在释放前只能有一个线程执行，而

time.sleep(2)

这句代码放在

lock.release()

前的时候，因为有2个线程，每个线程操作3次，因此耗时

2 * 3 * 2 = 12秒

；

但是当

lock.release()

这句代码放在

time.sleep(2)

前的时候，即先释放锁，再等待，由于释放了锁后，释放锁的线程在等待2秒，而另一个线程立即获取锁，然后进行计算操作，由于计算操作的时间很快，

可忽略不计

，最后就会出现2个线程都在

同时

(可以认为是同时)执行等待2秒这个操作，因此最后实际上只耗费了一个线程的时间

3 * 2 = 6秒