python多线程之 threading模块详解

Posted 2020-07-20 billiepander

一：死锁

　　在死锁之前需要先了解的概念是“可抢占资源”与“不可抢占资源”【此处的资源可以是硬件设备也可以是一组信息】，因为死锁是与不可抢占资源有关的。

　　可抢占资源：可以从拥有他的进程中抢占而不会发生副作用。e.g：存储器就是一类可抢占资源（假设有A, B两个进程都想用打印机对256MB的用户内存进行打印，若A已经获得打印机并且开始打印，但是在没有打印完成其时间片就用完并被换出了，此时B进程开始运行“抢占了”内存并开始请求打印机，但是A进程还拥有打印机所以B进程没有抢占打印机成功，此时由于双方都缺少一个对方拥有的资源，双方都不能执行，有死锁的危险，不过实际上系统会把进程B换出内存，重新将进程A换入内存 [也就是A进程反过来抢占了B进程的内存资源]，效果也就是进程A继续执行直到完成并释放打印机，而后B进程就能够执行了）。从中可以看出由于可抢占资源可以通过重新分配资源而避免了死锁的发生，所以可抢占资源是不会发生死锁现象的。

　　不可抢占资源：在不引起相关计算失败的情况下，无法把它从占有它的进程处抢占过来的资源。e.g：刻录机（假设一个进程已经开始刻盘，突然将刻录机分配给另一个进程，那么将划坏CD盘，所以任何时候刻录机都是不能被抢占的）

　　死锁：当多个进程需要排他性的访问多个资源，且其所需要的资源在同一时间属于不同进程且还是不可抢占资源的时候，此时相关进程就会一直请求对应资源但得不到从而一直阻塞下去，这就是死锁现象。

 　　*除了硬件机器与I/O设备之外，别的情况也可能引起死锁，比如一个数据库系统中，为了避免竞争可对若干记录加锁，假设进程A对记录R1加锁而进程B岁记录R2加锁，接着他们又各自试着加锁对方的记录，此时也会发生死锁

 

注：关于GIL（global interpreter lock），可参见这篇文章：http://www.dabeaz.com/python/UnderstandingGIL.pdf

二：Threading模块

2.1.threading.Thread对象【创建线程的主要对象】：

　　方法：start()：启动线程

　　　　   run()：启动线程后自动调用的方法

　　　　　join([timeout])：等待到被调用的线程终止

　　　　   is_alive()：返回线程活动状态

　　属性：name：线程名

　　　　   ident：线程ID号

　　　　   daemon：后台标志

2.2.创建线程的方法：

　　1:实例化threading.Thread对象

　　　　ths = threading.Thread( target = None, name = None, args = (), kwarg = {} )

　　　　　　　　　　　　　　　　  传入函数名　       线程名          函数的参数

　　2:继承threading中的Thread对象后再实例化并启动

 

2.3.以不同的线程类型分：

　　令：t = threading.Thread(target=dmn...)，即是t为一个线程

　　2.3.1.独立线程：就是最简单的独立单线程

　　2.3.2.线程等待：t.join([timeout])，放到start（）后，表明t线程执行完后（或是指定时间后）才轮到下一个线程【若是因为指定时间的话还会跳回t线程】

 1 #coding:utf-8
 2 import threading, time
 3 class MyThread(threading.Thread):
 4 
 5     def run(self):
 6         for i in range(40):
 7             print()    #若是t线程在执行时就是打印换行
 8             time.sleep(0.1)
 9 
10 if __name__ == "__main__":
11     t = MyThread()
12     t.start()
13     **t.join()**
14     for i in range(10):    #此部分是主线程执行的,也就是说此程序有主线程与t线程两个线程
15         print("main:", i)
16         time.sleep(0.1)    
17 
18 #最后会在打印完了换行后才打印0到9的“main：...”, 说明t线程执行完了后主线程才执行的

线程等待示例

　　2.3.3.后台线程（在主线程退出后立即自杀）：设置daemon属性为True【 t.daemon = True】

　　2.3.4.线程同步：指的是多个线程同时需要用到的资源，此时为了保证一致性有多种不同的加锁处理机制【获取了锁的线程可以对此资源进行操作，而没有的线程处于阻塞状态】，如下：

　　　　1）先到先用---指令锁：threading.Lock对象

　　　　　　定义锁变量：lock = threading.Lock()

　　　　　　锁定资源：lock.acquire()

　　　　　　释放资源：lock.release()

 1 import threading, time, random
 2 share = 4
 3 class MyThread(threading.Thread):
 4     def __init__(self,i):
 5         super().__init__()
 6         self.i = i
 7 
 8     def run(self):
 9         global share
10         for d in range(40):
11             **lock.acquire()**
12             print(share)
13             share += self.i
14             time.sleep(random.random())
15             print("t+", self.i, "=", share)
16             **lock.release()**
17 
18 **lock = threading.Lock()**
19 
20 if __name__ == "__main__":
21     t = MyThread(2)
22     tt = MyThread(6)
23     t.start()
24     # t.join()
25     tt.start()
26 
27 #会看到一会儿加2，一会儿加6
28 #若将倒数第二行注释去除，则一直加2，完了后才加6

指令锁示例

　　　　2）可重入锁：被某一线程锁定了后还可以被其他线程锁定

　　　　3）有先后顺序的使用---条件变量：threading.Condition对象（创建了一个带锁的线程池）, [当具备了某条件后才调用某线程，如生产者-消费者模式]

　　　　　　定义锁变量：conLock  = threading.Condition()

　　　　　　获得锁：conLock.acquire()

　　　　　　通知线程池里其他线程：conLock.notify( [ n=x ] )【唤起x个,默认为1】，clock.notify_all()【唤醒全部】

　　　　　　释放锁并且进入线程池等待：conLock.wait()

 1 #coding:utf-8
 2 import threading, time
 3 share = 0
 4 **share_condition = threading.Condition()**
 5 
 6 class ProductThread(threading.Thread):
 7     def __init__(self):
 8         super().__init__()
 9         self.name = "生产者"
10 
11     def run(self):
12         global share
13         if share_condition.acquire():
14             while True:
15                 if not share:
16                     share += 1
17                     print( self.name, share )
18                     **share_condition.notify()**       #执行线程池里的一个等待线程
19                 **share_condition.wait()**             #当前线程释放锁并将当前线程放入线程池等待下次notify()，所以如果没有此句则只会显示一句“生产者：1”
20                 time.sleep(1)
21 
22 class CustumerThread(threading.Thread):
23     def __init__(self):
24         super().__init__()
25         self.name = "消费者"
26 
27     def run(self):
28         global share
29         if share_condition.acquire():
30             while True:
31                 if share:
32                     share -= 1
33                     print( self.name, share )
34                     **share_condition.notify()**
35                 **share_condition.wait()**
36                 time.sleep(1)
37 
38 lock = threading.Lock()
39 
40 if __name__ == "__main__":
41     product = ProductThread()
42     customer = CustumerThread()
43     product.start()
44     customer.start()
45 
46 
47 #最后会相继打印：
48 # 生产者 1
49 # 消费者 0

条件变量锁机制示例

　　　　4）部分线程同时使用---信号量：threading.Semaphore对象

　　　　　　定义锁：sema = threading.Semaphore(n)  #允许同时有n个线程获得锁

　　　　　　获得锁：sema.acquire()

　　　　　　释放锁：sema.release()

　　　　　　常用于限制资源的访问，比如数据库的连接池

 1 #coding:utf-8
 2 import threading, time
 3 class MyThread(threading.Thread):
 4     def __init__(self,name):
 5         super().__init__()
 6         self.name = name
 7 
 8     def run(self):
 9         if sema.acquire():
10             print(self.name,"得到了锁")
11             time.sleep(1)
12         sema.release()
13         print(self.name,\'释放了锁\')
14 
15 sema = threading.Semaphore(2)
16 
17 if __name__ == "__main__":
18     threads = [ MyThread(str(i)+"sema") for i in range(5) ]
19     for thread in threads:
20         thread.start()
21 
22 #输出如下，可以看出同时能够有两个线程获得了锁
23 # 0sema 得到了锁
24 # 1sema 得到了锁
25 # 0sema 释放了锁
26 # 1sema 释放了锁
27 # 2sema 得到了锁
28 # 3sema 得到了锁
29 # 2sema 释放了锁
30 # 4sema 得到了锁
31 # 3sema 释放了锁
32 # 4sema 释放了锁

信号量锁示例

　　　　5）线程间通信---threading.Event对象（创建了一个带有标志的线程池,当一个线程设置内部标志为True后线程池中的等待线程就会被唤醒并执行）【即是当前执行线程可以决定啥时候（一般是所共同使用的资源已经使用完毕了后）“叫醒”别的线程，需要注意的是，若此时叫醒别人的线程并没有wait进入线程池，那么如果其还有代码的话将继续执行下去】

　　　　　　定义锁变量： event = threading.Event()

　　　　　　进入线程池等待：event.wait([timeout])

　　　　　　设置内部标志为True：event.set()  <--->  event.clear()

 1 #coding:utf-8
 2 import threading, time
 3 
 4 class WaitThread(threading.Thread):
 5 
 6     def run(self):
 7         self.name = "等待线程"
 8         print(self.name,"正在等待") #注意此程序的执行顺序，先调用的此线程执行到这里
 9         **event.wait()**               #在此此线程wait进入线程池等待，切换到mainThread直至设置标志
10         print(self.name,"启动了")  #从而此线程在此被唤醒执行
11         **event.clear()**              #而后设置标志为false
12 
13 class MainThread(threading.Thread):
14 
15     def run(self):
16         time.sleep(3)
17         print("主线程更改了标志")
18         **event.set()**
19         print("这里的会在WaitThread打印启动了前打印吗？") 
20 
21 **event = threading.Event()**
22 
23 if __name__ == "__main__":
24     wt = WaitThread()
25     mt = MainThread()
26     wt.start()
27     mt.start()
28 
29 # 输出：
30 # 等待线程 正在等待
31 # 主线程更改了标志
32 # 这里的会在WaitThread打印启动了前打印吗？
33 # 等待线程 启动了

线程间通信锁示例

　　　　

*补充.关于定时执行：threading.Timer()

 

参考:

《现代操作系统》---Andrew S. Tanebaum