简单阐述python多线程

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秒