python第五十一天----線程,Event,隊列

進程與線程的區別:

線程==指令集，進程==資源集  （線程集）

1、同一個進程中的線程共用記憶體空間,進程與進程之間是獨立的

2、同一個進程中的線程是可以直接通訊交流的，進程與間通訊必需通過一個中間的代理才能實現

3、創建線程簡單，創建進程，是克隆父進程 

4、一個線程可以控制和操作同一進程里的其他線程，但進程只能操作子進程

5、線程啟動速度快，進程啟動速度比較慢

線程示例：

 1 import time ,threading
 2 
 3 def run(attr):
 4     print('輸出:',attr)
 5     time.sleep(3)
 6 
 7 
 8 t1=threading.Thread(target=run,args=('第一個線程',))
 9 t2=threading.Thread(target=run,args=('第二個線程',))
10 
11 t1.start()#啟動線程1
12 t2.start()#啟動線程2

1 def run2(attr):
2     print('輸出:',attr)
3     time.sleep(3)
4 
5 run2('第一個線程')
6 run2('第二個線程')
7 #以上轉為串聯執行

繼承線程 類寫線程

 1 #！usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 
 5 import threading,time
 6 
 7 class thre(threading.Thread):#繼承線程中的類
 8     def __init__(self,n,times):
 9         super(thre,self).__init__()
10         self.n=n
11         self.teims=times
12     def run(self):
13         print('執行第一線程:',self.n)
14         time.sleep(self.teims)
15 
16 star_time=time.time()
17 t1=thre('第一線程',3)
18 t2=thre('第二線程',4)
19 t1.start()
20 t2.start()
21 t1.join()#join等待該線程執行完成
22 
23 t2.join()
24 den_time=time.time()-star_time
25 print(den_time)

等待線程執行完成，用.join

 1 import time ,threading
 2 lock=threading.Lock()#定義一個線程鎖變數
 3 def run(attr):
 4     lock.acquire()#申請一個線程鎖
 5     global num
 6     print('輸出:',attr)
 7     #time.sleep(3)
 8     num+=1
 9     lock.release()#釋放線程鎖
10     time.sleep(3)
11     print('輸出完成'.center(10,'〓'))
12 star_time=time.time()#開始時間
13 
14 num=0
15 re_lilst=[]#定義一個列表
16 for i in range(50):
17     t1=threading.Thread(target=run,args=(('第%s線程'%i),))#新建線程
18     #t1.setDaemon(True)#設置為守護進程 當主線程完成,守護也停止
19     t1.start()#起動線程
20     re_lilst.append(t1)#不用JOIN,避免阻塞為串列
21 
22 print(threading.current_thread(),threading.active_count())#查看線程 的主 子  活躍線程
23     #print('分線程'.center(40,'☆'))
24 print('數字:',num)
25 for i in re_lilst:#等待線程 完成
26     i.join()
27 print('數字:',num)
28 print('主線程'.center(60,'◇'),threading.current_thread(),threading.active_count())
29 
30 den_time=time.time()-star_time#總共時間
31 print(den_time)

守護進程，相當於主進程的下屬，當主進程結束，無論守護進程內的是否執行完成，都會停止！

 1 import time ,threading
 2 lock=threading.Lock()#定義一個線程鎖變數
 3 def run(attr):
 4     lock.acquire()#申請一個線程鎖
 5     global num
 6     print('輸出:',attr)
 7 
 8     #time.sleep(3)
 9     num+=1
10     lock.release()#釋放線程鎖
11     time.sleep(3)
12     print('輸出完成'.center(10,'〓'))
13 
14 star_time=time.time()#開始時間
15 
16 num=0
17 re_lilst=[]#定義一個列表
18 for i in range(50):
19     t1=threading.Thread(target=run,args=(('第%s線程'%i),))#新建線程
20     t1.setDaemon(True)#設置為守護進程 當主線程完成,守護也停止
21     t1.start()#起動線程
22     re_lilst.append(t1)#不用JOIN,避免阻塞為串列
23 
24 print(threading.current_thread(),threading.active_count())#查看線程 的主 子  活躍線程
25     #print('分線程'.center(40,'☆'))
26 print('數字:',num)
27 # for i in re_lilst:#等待線程 完成
28 #    i.join()
29 print('數字:',num)
30 print('主線程'.center(60,'◇'),threading.current_thread(),threading.active_count())
31 
32 den_time=time.time()-star_time#總共時間
33 print(den_time)

線程鎖，在py3中可以不使用：

lock=threading.Lock()

lock.acquire()

遞歸鎖  用於遞歸線程

 1 import time ,threading
 2 
 3 def run(i):
 4     print('輸出:-------',i)
 5     lock.acquire()#申請鎖
 6     global num1
 7     num1+=1
 8     time.sleep(0.1)
 9     lock.release()#釋放鎖
10     return num1
11 
12 def run2(i):
13     lock.acquire()#申請鎖
14     global num2
15     print('輸出:22',i)
16     num2+=1
17     time.sleep(0.1)
18     lock.release()#釋放鎖
19     return num2
20 
21 def run3(i):
22     lock.acquire()#申請鎖
23     res=run(i)
24     print('輸出:333',i)
25     res2=run2(i)
26     time.sleep(0.1)
27     print(res,res2)
28     lock.release()#釋放鎖
29 
30 
31 if __name__ == '__main__':
32     star_time=time.time()#開始時間\
33     num1,num2=0,0
34     #lock=threading.Lock()#定義一個線程鎖,如是線程鎖,遞歸時會出錯
35     lock=threading.RLock()#定義一個遞歸鎖
36 
37     for i in range(10):
38         #t1=threading.Thread(target=run,args=(('第%s線程'%i),))#新建線程
39         t1=threading.Thread(target=run3,args=(('第%s線程'%i),))#新建線程
40         t1.start()#起動線程
41 
42     else:
43         print('活躍線程數:',threading.active_count())#查看線程 活躍線程數
44 
45 
46 while threading.active_count()!=1:#不只一個線程,就是說,判斷是否是剩下主線程
47     #print(threading.active_count())#查看線程 活躍線程數
48     pass
49 else:
50     print('主線程:pid,活躍線程數'.center(60,'◇'),threading.current_thread(),threading.active_count())#
51     den_time=time.time()-star_time#總共時間
52     print(den_time)
53     print(num1,num2)

信號量  相當與 多個線程鎖 

 1 #！usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 
 5 #！usr/bin/env python
 6 #-*-coding:utf-8-*-
 7 # Author calmyan
 8 import time ,threading
 9 
10 def run(attr):
11     semaphore.acquire()#申請信號量線程鎖
12     global num
13     print('輸出:',attr)
14     time.sleep(1)
15     semaphore.release()#釋放信號量線程鎖
16 
17 star_time=time.time()#開始時間
18 if __name__ == '__main__':
19 
20     semaphore=threading.BoundedSemaphore(4)#信號量 最多允許幾個線程同時運行(多把鎖)
21     for i in range(50):
22         t1=threading.Thread(target=run,args=(('第%s線程'%i),))#新建線程
23         t1.start()#起動線程
24 
25 while threading.active_count()!=1:#不只一個線程,就是說,判斷是否是剩下主線程
26     pass
27 else:
28     print('主線程'.center(60,'◇'),threading.current_thread(),threading.active_count())
29     den_time=time.time()-star_time#總共時間
30     print(den_time)

Event 線程標誌

紅綠燈示例

 1 #！usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 
 5 import threading,time
 6 
 7 event=threading.Event()#生成一個標示位對象
 8 def lighter():#
 9     count=0 #定義時間秒數
10     event.set()#設置標誌位
11     while True:
12         if count>9 and count<15:#設定為紅燈
13             event.clear()#清除標誌位,
14             print('\033[41;1m變為紅燈!\033[0m')
15         elif count>=15 and count<18 :#為黃燈
16 
17             print('\033[43;1m變為黃燈!\033[0m')
18         elif count>=18:
19             event.set()#設置標誌位
20             print('\033[42;1m變為綠燈!\033[0m')
21             count=0#重新計時
22         else:
23             print('\033[42;1m綠燈中.....!\033[0m')
24         time.sleep(1)
25         count+=1#每一秒鐘加一次
26 
27 
28 def car(name):
29     while True:
30         if event.is_set():#如果有標誌 說明為綠燈
31             print('[%s]在行駛中....'%name)
32             time.sleep(1)
33         else:
34             print('[%s]在等待中.....'%name)
35             event.wait()#等待獲取標誌
36             print('綠燈亮了,[%s]繼續行駛...'%name)
37             time.sleep(1)
38 
39 
40 light=threading.Thread(target=lighter,)#定義一個線程
41 light.start()#啟動線程
42 
43 car1=threading.Thread(target=car,args=('紅旗轎車',))#生成一個汽車線程
44 car1.start()

隊列  生產者消費者模型

 1 #！usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 
 5 #隊列 生產者消費者模型
 6 
 7 import threading,time,queue
 8 
 9 q=queue.Queue()#創建一個隊列
10 
11 def produ(name):#生產函數
12     count=0
13     while True:
14         bz=name+str(count)
15         q.put(bz)
16         print('[%s]生產了,第[%s]個[%s]g 包子'%(name,count,bz))
17         count+=1
18         time.sleep(1.5)
19 
20 def consump(name):#消費者
21     while True:
22         i=q.get()#取
23         print('[%s]拿到包子[%s],並吃了'%(name,i))
24         time.sleep(0.5)
25 
26 
27 p1=threading.Thread(target=produ,args=('王五包子鋪',))#創建一個新線程 生產者
28 p2=threading.Thread(target=produ,args=('麻子六包子鋪',))#創建一個新線程 生產者
29 r1=threading.Thread(target=consump,args=('張三',))#創建一個新線程 消費者
30 r2=threading.Thread(target=consump,args=('李四',))#創建一個新線程 消費者
31 p1.start()
32 p2.start()
33 r1.start()
34 r2.start()