對于操作系統來說，一個任務就是一個進程(Process)，比如打開一個瀏覽器就是啟動一個瀏覽器進程，打開一個記事本就啟動了一個記事本進程，打開兩個記事本就啟動了兩個記事本進程，打開一個Word就啟動了一個Word進程。

有些進程還不止同時干一件事，比如Word，它可以同時進行打字、拼寫檢查、打印等事情。在一個進程內部，要同時干多件事，就需要同時運行多個“子任務”，我們把進程內的這些“子任務”稱為線程(Thread)。

進程

Python的os模塊封裝了常見的系統調用，其中包括fork，可以在Python程序中輕松創建子進程：

importos

print('Process(%s)start...'%os.getpid())

#OnlyworksonUnix/Linux/Mac:

pid=os.fork()

ifpid==0:

print('Iamchildprocess(%s)andmyparentis%s.'%(os.getpid(),os.getppid()))

else:

print('I(%s)justcreatedachildprocess(%s).'%(os.getpid(),pid))

運行結果如下：

Process(876)start...

I(876)justcreatedachildprocess(877).

Iamchildprocess(877)andmyparentis876.

由于Windows沒有fork調用，上面的代碼在Windows上無法運行。由于Mac系統是基于BSD(Unix的一種)內核，所以，在Mac下運行是沒有問題的，推薦大家用Mac學Python!

multiprocessing

如果你打算編寫多進程的服務程序，Unix/Linux無疑是正確的選擇。由于Windows沒有fork調用，難道在Windows上無法用Python編寫多進程的程序?

由于Python是跨平臺的，自然也應該提供一個跨平臺的多進程支持。multiprocessing模塊就是跨平臺版本的多進程模塊。

multiprocessing模塊提供了一個Process類來代表一個進程對象，下面的例子演示了啟動一個子進程并等待其結束：

frommultiprocessingimportProcess

importos

#子進程要執行的代碼

defrun_proc(name):

print('Runchildprocess%s(%s)...'%(name,os.getpid()))

if__name__=='__main__':

print('Parentprocess%s.'%os.getpid())

p=Process(target=run_proc,args=('test',))

print('Childprocesswillstart.')

p.start()

p.join()

print('Childprocessend.')

執行結果如下：

Parentprocess928.

Processwillstart.

Runchildprocesstest(929)...

Processend.

創建子進程時，只需要傳入一個執行函數和函數的參數，創建一個Process實例，用start()方法啟動，這樣創建進程比fork()還要簡單。

join()方法可以等待子進程結束后再繼續往下運行，通常用于進程間的同步。

線程

Python的標準庫提供了兩個模塊：_thread和threading，_thread是低級模塊，threading是高級模塊，對_thread進行了封裝。絕大多數情況下，我們只需要使用threading這個高級模塊。

啟動一個線程就是把一個函數傳入并創建Thread實例，然后調用start()開始執行：

importtime,threading

#新線程執行的代碼:

defloop():

print('thread%sisrunning...'%threading.current_thread().name)

n=0

whilen<5:

n=n+1

print('thread%s>>>%s'%(threading.current_thread().name,n))

time.sleep(1)

print('thread%sended.'%threading.current_thread().name)

print('thread%sisrunning...'%threading.current_thread().name)

t=threading.Thread(target=loop,name='LoopThread')

t.start()

t.join()

print('thread%sended.'%threading.current_thread().name)

執行結果如下：

threadMainThreadisrunning...

threadLoopThreadisrunning...

threadLoopThread>>>1

threadLoopThread>>>2

threadLoopThread>>>3

threadLoopThread>>>4

threadLoopThread>>>5

threadLoopThreadended.

threadMainThreadended.

Lock

多線程和多進程最大的不同在于，多進程中，同一個變量，各自有一份拷貝存在于每個進程中，互不影響，而多線程中，所有變量都由所有線程共享，所以，任何一個變量都可以被任何一個線程修改，因此，線程之間共享數據最大的危險在于多個線程同時改一個變量，把內容給改亂了。

balance=0

lock=threading.Lock()

defrun_thread(n):

foriinrange(100000):

#先要獲取鎖:

lock.acquire()

try:

#放心地改吧:

change_it(n)

finally:

#改完了一定要釋放鎖:

lock.release()

當多個線程同時執行lock.acquire()時，只有一個線程能成功地獲取鎖，然后繼續執行代碼，其他線程就繼續等待直到獲得鎖為止。

獲得鎖的線程用完后一定要釋放鎖，否則那些苦苦等待鎖的線程將永遠等待下去，成為死線程。所以我們用try...finally來確保鎖一定會被釋放。

ThreadLocal

importthreading

#創建全局ThreadLocal對象:

local_school=threading.local()

defprocess_student():

#獲取當前線程關聯的student:

std=local_school.student

print('Hello,%s(in%s)'%(std,threading.current_thread().name))

defprocess_thread(name):

#綁定ThreadLocal的student:

local_school.student=name

process_student()

t1=threading.Thread(target=process_thread,args=('Alice',),name='Thread-A')

t2=threading.Thread(target=process_thread,args=('Bob',),name='Thread-B')

t1.start()

t2.start()

t1.join()

t2.join()

執行結果：

Hello,Alice(inThread-A)

Hello,Bob(inThread-B)

全局變量local_school就是一個ThreadLocal對象，每個Thread對它都可以讀寫student屬性，但互不影響。你可以把local_school看成全局變量，但每個屬性如local_school.student都是線程的局部變量，可以任意讀寫而互不干擾，也不用管理鎖的問題，ThreadLocal內部會處理。

可以理解為全局變量local_school是一個dict，不但可以用local_school.student，還可以綁定其他變量，如local_school.teacher等等。

ThreadLocal最常用的地方就是為每個線程綁定一個數據庫連接，HTTP請求，用戶身份信息等，這樣一個線程的所有調用到的處理函數都可以非常方便地訪問這些資源。

以上內容為大家介紹了Python學習之進程和線程，希望對大家有所幫助，如果想要了解更多Python相關知識，請關注IT培訓機構:千鋒教育。http://m.hangjiakeji.com/