简单阐述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('主线程结束...')

这是运行两次的结果:

简单阐述python多线程_第1张图片

简单阐述python多线程_第2张图片

执行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次的输出却是:

简单阐述python多线程_第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次的结果:

简单阐述python多线程_第4张图片

可以看到,没有出错。

时间问题

假设对 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))

img

输出耗时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))

img

这时输出为 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秒

你可能感兴趣的:(python入门,python,多线程)