Python之線程與進程
阿新 • • 發佈：2017-08-24
調度 .py 關閉 接口 har 出現 控制 release pre 
1.程序
程序指的是指令的集合；程序不能單獨的運行，必須將程序裝載在內存中，系統給它分配資源才可以運行。
程序是進程動態運行的靜態描述文本
2.進程
進程指的是程序在數據集中一次動態運行的過程；
3.線程
線程進程的最小執行單位，真正在CPU運行的是線程
4.進程與線程的關系
一個線程只能在一個進程裏面，一個進程可以包含多個線程； 進程是資源管理單位（容器） 線程是最小執行單位
5.並行與並發
並行：指的是同時處理多個任務（多個線程被不同的CPU執行）
並發：指的是交替處理多個任務（多個線程被一個CPU執行）
6.同步與異步
同步：請求數據的時候，如果被請求方沒有返回數據，那麽程序就會一直等下去，不會執行下面的操作，直到接收到返回的數據。（單線程）
異步：不會等下去，而是直接執行下面的操作，如果有數據返回，那麽系統會通知進程去處理（多線程）
這些知識概念的性的知識，現在開始了解下線程和進程吧！
線程：threading模塊
import time import threading def f1(): print(11) def f2(a1,a2): time.sleep(10) print(a1,a2) f1() t=threading.Thread(target=f2,args=(22,33)) t.start() t=threading.Thread(target=f2,args=(44,55)) t.start() t=threading.Thread(target=f2,args=(66,77)) t.start()
上面代碼創建了3個前臺線程，然後控制器就交給了CPU，CPU根據指定算法進行調度，分片執行指令。
更多方法：
- start 線程準備就緒，等待CPU調度
- setName 為線程設置名稱
- getName 獲取線程名稱
- setDaemon 設置為後臺線程或前臺線程（默認為False）
如果是後臺線程，主線程執行過程中，後臺線程也在進行，主線程執行完畢後，後臺線程不論成功與否，均停止（設置為True）
如果是前臺線程，主線程執行過程中，前臺線程也在進行，主線程執行完畢後，等待前臺線程也執行完成後，程序停止 - join 逐個執行每個線程，執行完畢後繼續往下執行，該方法使得多線程變得無意義
- run 線程被cpu調度後自動執行線程對象的run方法
import threading import time class MyThread(threading.Thread): def __init__(self,num): threading.Thread.__init__(self) self.num = num def run(self):#定義每個線程要運行的函數 print("running on number:%s" %self.num) time.sleep(3) if __name__ == ‘__main__‘: t1 = MyThread(1) t2 = MyThread(2) t1.start() t2.start()自定義線程類
線程鎖（Lock、RLock）
由於線程之間是進行隨機調度，並且每個線程可能只執行n條執行之後，當多個線程同時修改同一條數據時可能會出現臟數據，所以，出現了線程鎖 - 同一時刻允許一個線程執行操作。
import threading import time gl_num = 0 def show(arg): global gl_num time.sleep(1) gl_num +=1 print gl_num for i in range(10): t = threading.Thread(target=show, args=(i,)) t.start() print ‘main thread stop‘未使用鎖
import threading import time gl_num = 0 lock = threading.RLock() def Func(): lock.acquire() global gl_num gl_num +=1 time.sleep(1) print gl_num lock.release() for i in range(10): t = threading.Thread(target=Func) t.start()
信號量（Semaphore）
互斥鎖 同時只允許一個線程更改數據，而Semaphore是同時允許一定數量的線程更改數據 ，比如廁所有3個坑，那最多只允許3個人上廁所，後面的人只能等裏面有人出來了才能再進去。
import threading,time def run(n): semaphore.acquire() time.sleep(1) print("run the thread: %s" %n) semaphore.release() if __name__ == ‘__main__‘: num= 0 semaphore = threading.BoundedSemaphore(5) #最多允許5個線程同時運行 for i in range(20): t = threading.Thread(target=run,args=(i,)) t.start()
事件（event）
python線程的事件用於主線程控制其他線程的執行，事件主要提供了三個方法 set、wait、clear。
事件處理的機制：全局定義了一個“Flag”，如果“Flag”值為 False，那麽當程序執行 event.wait 方法時就會阻塞，如果“Flag”值為True，那麽event.wait 方法時便不再阻塞。
- clear：將“Flag”設置為False
- set：將“Flag”設置為True
import threading def run(n): con.acquire() con.wait() print("run the thread: %s" %n) con.release() if __name__ == ‘__main__‘: con = threading.Condition() for i in range(10): t = threading.Thread(target=run, args=(i,)) t.start() while True: inp = input(‘>>>‘) if inp == ‘q‘: break con.acquire() con.notify(int(inp)) con.release()
def condition_func(): ret = False inp = input(‘>>>‘) if inp == ‘1‘: ret = True return ret def run(n): con.acquire() con.wait_for(condition_func) print("run the thread: %s" %n) con.release() if __name__ == ‘__main__‘: con = threading.Condition() for i in range(10): t = threading.Thread(target=run, args=(i,)) t.start()
Timer
定時器，指定n秒後執行某操作
from threading import Timer def hello(): print("hello, world") t = Timer(1, hello) t.start() # after 1 seconds, "hello, world" will be printed
進程
from multiprocessing import Process import threading import time def foo(i): print ‘say hi‘,i for i in range(10): p = Process(target=foo,args=(i,)) p.start()
註意：由於進程之間的數據需要各自持有一份，所以創建進程需要的非常大的開銷。
進程數據共享
進程各自持有一份數據，默認無法共享數據
#!/usr/bin/env python #coding:utf-8 from multiprocessing import Process from multiprocessing import Manager import time li = [] def foo(i): li.append(i) print ‘say hi‘,li for i in range(10): p = Process(target=foo,args=(i,)) p.start() print ‘ending‘,li進程間默認無法數據共享
#方法一，Array from multiprocessing import Process,Array temp = Array(‘i‘, [11,22,33,44]) def Foo(i): temp[i] = 100+i for item in temp: print i,‘----->‘,item for i in range(2): p = Process(target=Foo,args=(i,)) p.start() #方法二：manage.dict()共享數據 from multiprocessing import Process,Manager manage = Manager() dic = manage.dict() def Foo(i): dic[i] = 100+i print dic.values() for i in range(2): p = Process(target=Foo,args=(i,)) p.start() p.join()
復制代碼 ‘c‘: ctypes.c_char, ‘u‘: ctypes.c_wchar, ‘b‘: ctypes.c_byte, ‘B‘: ctypes.c_ubyte, ‘h‘: ctypes.c_short, ‘H‘: ctypes.c_ushort, ‘i‘: ctypes.c_int, ‘I‘: ctypes.c_uint, ‘l‘: ctypes.c_long, ‘L‘: ctypes.c_ulong, ‘f‘: ctypes.c_float, ‘d‘: ctypes.c_double 復制代碼類型對應表
from multiprocessing import Process, Queue def f(i,q): print(i,q.get()) if __name__ == ‘__main__‘: q = Queue() q.put("h1") q.put("h2") q.put("h3") for i in range(10): p = Process(target=f, args=(i,q,)) p.start()View Code
當創建進程時（非使用時），共享數據會被拿到子進程中，當進程中執行完畢後，再賦值給原值。
from multiprocessing import Process, Array, RLock def Foo(lock,temp,i): """ 將第0個數加100 """ lock.acquire() temp[0] = 100+i for item in temp: print i,‘----->‘,item lock.release() lock = RLock() temp = Array(‘i‘, [11, 22, 33, 44]) for i in range(20): p = Process(target=Foo,args=(lock,temp,i,)) p.start()進程鎖實例
進程池
進程池內部維護一個進程序列，當使用時，則去進程池中獲取一個進程，如果進程池序列中沒有可供使用的進進程，那麽程序就會等待，直到進程池中有可用進程為止。
進程池中有兩個方法：
- apply
- apply_async
from multiprocessing import Process,Pool import time def Foo(i): time.sleep(2) return i+100 def Bar(arg): print arg pool = Pool(5) #print pool.apply(Foo,(1,)) #print pool.apply_async(func =Foo, args=(1,)).get() for i in range(10): pool.apply_async(func=Foo, args=(i,),callback=Bar) print ‘end‘ pool.close() pool.join()#進程池中進程執行完畢後再關閉，如果註釋，那麽程序直接關閉。View Code
協程
線程和進程的操作是由程序觸發系統接口，最後的執行者是系統；協程的操作則是程序員。
協程存在的意義：對於多線程應用，CPU通過切片的方式來切換線程間的執行，線程切換時需要耗時（保存狀態，下次繼續）。協程，則只使用一個線程，在一個線程中規定某個代碼塊執行順序。
協程的適用場景：當程序中存在大量不需要CPU的操作時（IO），適用於協程；
greenlet
from greenlet import greenlet def test1(): print 12 gr2.switch() print 34 gr2.switch() def test2(): print 56 gr1.switch() print 78 gr1 = greenlet(test1) gr2 = greenlet(test2) gr1.switch()
gevent
import gevent def foo(): print(‘Running in foo‘) gevent.sleep(0) print(‘Explicit context switch to foo again‘) def bar(): print(‘Explicit context to bar‘) gevent.sleep(0) print(‘Implicit context switch back to bar‘) gevent.joinall([ gevent.spawn(foo), gevent.spawn(bar), ])
遇到IO操作自動切換：
from gevent import monkey; monkey.patch_all() import gevent import urllib2 def f(url): print(‘GET: %s‘ % url) resp = urllib2.urlopen(url) data = resp.read() print(‘%d bytes received from %s.‘ % (len(data), url)) gevent.joinall([ gevent.spawn(f, ‘https://www.python.org/‘), gevent.spawn(f, ‘https://www.yahoo.com/‘), gevent.spawn(f, ‘https://github.com/‘), ])
Python之線程與進程