一、線程
線程是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以併發多個線程，每條線程並行執行不同的任務
方法：
start 線程準備就緒，等待CPU調度
setName 設置線程名稱
getName 獲取線程名稱
setDaemon 把一個主進程設置爲Daemon線程後，主線程執行過程中，後臺線程也在進行，主線程執行完畢後，後臺線程不論有沒執行完成，都會停止
join 逐個執行每個線程，執行完畢後繼續往下執行，該方法使得多線程變得無意義
run 線程被cpu調度後自動執行線程對象的run方法
threading模塊
線程的兩種調用方式：
1.直接調用（常用）
import threading
import time
'''直接調用'''
def hello(name):
print("Hello %s"%name)
time.sleep(3)
if __name__ == "__main__":
t1=threading.Thread(target=hello,args=("zhangsan",)) #生成線程實例
t2=threading.Thread(target=hello,args=("lisi",))
t1.setName("aaa") #設置線程名
t1.start() #啓動線程
t2.start()
t2.join() #join 等待t2先執行完
print("Hello")
print(t1.getName()) #獲取線程名2.繼承式調用
'''繼承式調用'''
import threading
import time
class MyThread(threading.Thread):
def __init__(self,name):
threading.Thread.__init__(self)
self.name = name
def run(self):
print("Hello %s"%self.name)
time.sleep(3)
if __name__ == "__main__":
t1=MyThread("zhangsan")
t2=MyThread("lisi")
t1.start()
t2.start()setDaemon線程
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading
def run(n):
print('Hello..[%s]\n' % n)
time.sleep(2)
def main():
for i in range(5):
t = threading.Thread(target=run,args=[i,])
t.start()
t.join(1)
m = threading.Thread(target=main,args=[])
m.setDaemon(True) #將主線程設置Daemon設置爲True後,主線程執行完成時,其它子線程會同時退出,不管是否執行完任務
m.start()
print("--- done----")
線程鎖Lock
一個進程下可以啓動多個線程，多個線程共享父進程的內存空間，每個線程可以訪問同一份數據，所以當多個線程同時要修改同一份數據時，就會出現錯誤
例如：
#!/usr/bin/env python # -*- coding:utf-8 -*- import threading import time num = 100 #設置一個共享變量 def show(): global num #在函數內操作函數外變量，需設置爲全局變量 time.sleep(1) num -= 1 list=[] for i in range(100): t = threading.Thread(target=show) t.start() list.append(t) for t in list: t.join() print(num)
上面的例子在正常執行完成後的num的結果應該是0，但實際上每次的執行結果都不太一樣，因爲當多個線程同時要修改同一份數據時，就會出現一些錯誤（只有
在python2.x運行纔會出現錯誤，python3.x中不會），所以每個線程在要修改公共數據時，爲了避免自己在還沒改完的時候別人也來修改此數據，可以加上線程鎖
來確保每次修改數據時只有一個線程在操作。
加鎖代碼
#!/usr/bin/env python # -*- coding:utf-8 -*- import threading import time num = 100 #設置一個共享變量 lock=threading.Lock() #生成全局鎖 def show(): global num #在函數內操作函數外變量，需設置爲全局變量 time.sleep(1) lock.acquire() #修改前加鎖 num -= 1 lock.release() #修改後解鎖 list=[] for i in range(100): t = threading.Thread(target=show) t.start() list.append(t) for t in list: t.join() print(num)
遞歸鎖RLock
就是在一個大鎖中再包含子鎖
#!/usr/bin/env python # -*- coding:utf-8 -*- import threading #遞歸鎖 def run1(): lock.acquire() #小鎖 global num num +=1 lock.release() return num def run2(): lock.acquire() #小鎖 global num2 num2+=1 lock.release() return num2 def run3(): lock.acquire() #大鎖 res = run1() res2 = run2() lock.release() print(res,res2) if __name__ == '__main__': num,num2 = 0,0 lock = threading.RLock() #生成Rlock for i in range(10): t = threading.Thread(target=run3) t.start() while threading.active_count() != 1:#如果不等於1，說明子線程還沒執行完畢 pass #打印進程數 else: print(num,num2)
Semaphore
同時允許一定數量的線程更改數據
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time
def run(n):
semaphore.acquire()
time.sleep(1)
print("run the thread: %s" %n)
semaphore.release()
if __name__ == '__main__':
semaphore = threading.BoundedSemaphore(3) #設置最多允許3個線程同時運行
for i in range(20):
t = threading.Thread(target=run,args=(i,))
t.start()
while threading.active_count() != 1:
pass
else:
print('----done---')event
實現兩個或多個線程間的交互，提供了三個方法 set、wait、clear，默認碰到event.wait 方法時就會阻塞。
event.set()，設定後遇到wait不阻塞
event.clear()，設定後遇到wait後阻塞
event.isSet()，判斷有沒有被設定
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
def start():
print("---start---1")
event.wait() #阻塞
print("---start---2")
if __name__ == "__main__":
event = threading.Event()
t = threading.Thread(target=start)
t.start()
result=input(">>:")
if result == "set":
event.set() #設定set，wait不阻塞二、進程
multiprocessing模塊
進程調用
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process
import time
def start(name):
time.sleep(1)
print('hello', name)
if __name__ == '__main__':
p = Process(target=start, args=('zhangsan',))
p1 = Process(target=start, args=('lisi',))
p.start()
p1.start()
p.join()進程間通訊
每個進程都擁有自己的內存空間，因此不同進程間內存是不共享的，要想實現兩個進程間的數據交換，有幾種方法
Queue（隊列）
#!/usr/bin/env python # -*- coding:utf-8 -*- from multiprocessing import Process, Queue def start(q): q.put( 'hello') if __name__ == '__main__': q = Queue() p = Process(target=start, args=(q,)) p.start() print(q.get()) p.join()
Pipe（管道，不常用）
把管道的兩頭分別賦給兩個進程，實現兩個進程的互相通信
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process, Pipe
def start(conn):
conn.send('hello')#發送
print(conn.recv())#接收
conn.close()
if __name__ == '__main__':
parent_conn, child_conn = Pipe() #生成一個管道
p = Process(target=start, args=(child_conn,))
p.start()
print(parent_conn.recv())#接收
parent_conn.send("11111")#發送
p.join()Manager（實現了進程間真正的數據共享）
#!/usr/bin/env python from multiprocessing import Process, Manager def f(dic, list,i): dic['1'] = 1 dic['2'] = 2 dic['3'] = 3 list.append(i) if __name__ == '__main__': manager = Manager() dic = manager.dict()#通過manager生成一個字典 list = manager.list(range(5))#通過manager生成一個列表 p_list = [] for i in range(10): p = Process(target=f, args=(dic, list,i)) p.start() p_list.append(p) for res in p_list: res.join() print(dic) print(list)
#執行結果
'''
{'2': 2, '3': 3, '1': 1}
[0, 1, 2, 3, 4, 1, 9, 2, 5, 3, 7, 6, 0, 8, 4]
'''進程池
進程池內部維護一個進程序列，當使用時，則去進程池中獲取一個進程，如果進程池序列中沒有可供使用的進程，那麼程序就會等待，直到進程池中有可用進程爲止。
進程池中有兩個方法：
1、apply（同步）
2、apply_async（異步）
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process,Pool
import time
def Foo(i):
time.sleep(1)
return i+100
def Bar(arg):
print('number::',arg)
if __name__ == "__main__":
pool = Pool(3)#定義一個進程池，裏面有3個進程
for i in range(10):
pool.apply_async(func=Foo, args=(i,),callback=Bar)
#pool.apply(func=Foo, args=(i,))
pool.close()#關閉進程池
pool.join()#進程池中進程執行完畢後再關閉,(必須先close在join)callback是回調函數，就是在執行完Foo方法後會自動執行Bar函數，並且自動把Foo函數的返回值作爲參數傳入Bar函數
三、協程
協程，又稱微線程，是一種用戶態的輕量級線程。協程能保留上一次調用時的狀態，每次過程重入時，就相當於進入上一次調用的狀態，換種說法：進入上一次離開時所處邏輯流的位置，當程序中存在大量不需要CPU的操作時（IO），適用於協程。
協程有極高的執行效率，因爲子程序切換不是線程切換，而是由程序自身控制，因此，沒有線程切換的開銷。
不需要多線程的鎖機制，因爲只有一個線程，也不存在同時寫變量衝突，在協程中控制共享資源不加鎖，只需要判斷狀態就好了，所以執行效率比多線程高很多。
因爲協程是一個線程執行，所以想要利用多核CPU，最簡單的方法是多進程+協程，這樣既充分利用多核，又充分發揮協程的高效率。
那符合什麼條件就能稱之爲協程：1、必須在只有一個單線程裏實現併發 2、修改共享數據不需加鎖 3、用戶程序裏自己保存多個控制流的上下文棧 4、一個協程遇到IO操作自動切換到其它協程
python中對於協程有兩個模塊，greenlet和gevent。
Greenlet（greenlet的執行順序需要我們手動控制）
#!/usr/bin/env python # -*- coding:utf-8 -*- from greenlet import greenlet def test1(): print (11) gr2.switch() #手動切換 print (22) gr2.switch() def test2(): print (33) gr1.switch() print (44) gr1 = greenlet(test1) gr2 = greenlet(test2) gr1.switch()
gevent（自動切換，由於切換是在IO操作時自動完成，所以gevent需要修改Python自帶的一些標準庫，這一過程在啓動時通過monkey patch完成）
from gevent import monkey; monkey.patch_all()
import gevent
import time
def foo():
print('11')
time.sleep(3)
print('22')
def bar():
print('33')
print('44')
gevent.joinall([
gevent.spawn(foo),
gevent.spawn(bar),
])運行結果：（從結果可以看出，它們是併發執行的）
11 33 44 22