簡要講解Python編程中線程的創建與鎖的使用

這篇文章主要介紹了簡要講解Python編程中線程的創建與鎖的使用,Python中雖然有GIL的存在,但依然是能夠創建多個線程來交替使用的,

創建線程
創建線程的兩種方法：
1，直接調用threading.Thread來構造thread對象，Thread的參數如下：
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={})
group為None；
target為線程將要執行的功能函數；
name為線程的名字，也可以在對象構造后調用setName()來設定；
args為tuple類型的參數，可以為多個，如果只有一個也的使用tuple的形式傳入，例如(1,)；
kwargs為dict類型的參數，也即位命名參數
threading.Thread對象的其他方法：
start()，用來啟動線程；
join(), 等待直到線程結束；
isAlive(),獲取線程狀態

setDeamon(), 設置線程為deamon線程，必須在start()調用前調用，默認為非demon。
注意： python的主線程在沒有非deamon線程存在時就會退出。

threading.currentthread() , 用來獲得當前的線程；
threading.enumerate() ， 用來多的當前存活的所有線程；    

運行結果    
I am Thread-1.num:0
I am Thread-1.num:1
I am Thread-1.num:2
I am Thread-2.num:0
I am Thread-2.num:1
I am Thread-2.num:2
I am Thread-3.num:0
I am Thread-3.num:1
I am Thread-3.num:2

2，直接從threading.Thread繼承，然后重寫__init__方法和run方法    
#coding:utf-8
import threading
class MyThread(threading.Thread): #繼承父類threading.Thread
 def __init__(self, num ):
  threading.Thread.__init__(self)
  self.num = num
    
 #把要執行的代碼寫到run函數里面 線程在創建后會直接運行run函數
 def run(self):
  for i in range(self.num):
   print 'I am %s.num:%s' % (self.getName(), i)
      
for i in range(3):
 t = MyThread(3)
 t.start()
 t.join()

運行結果
    
I am Thread-1.num:0
I am Thread-1.num:1
I am Thread-1.num:2
I am Thread-2.num:0
I am Thread-2.num:1
I am Thread-2.num:2
I am Thread-3.num:0
I am Thread-3.num:1
I am Thread-3.num:2


鎖的使用
假設我們有一個公共數據x(也可以叫共享資源，臨界資源)，然后跑10個線程都去訪問這變量并對這個變量進行修改的操作，那么就得到意料之外的結果。    
import threading       # 導入threading模塊
import time        # 導入time模塊
class mythread(threading.Thread):  # 通過繼承創建類
 def __init__(self,threadname):  # 初始化方法
  # 調用父類的初始化方法
  threading.Thread.__init__(self,name = threadname)
 def run(self):       # 重載run方法
  global x     # 使用global表明x為全局變量
  for i in range(3):
   x = x + 1
  time.sleep(2)   # 調用sleep函數，讓線程休眠5秒
  print x
                 
tl = []        # 定義列表
for i in range(10):
 t = mythread(str(i))    # 類實例化
 tl.append(t)      # 將類對象添加到列表中
                
x=0         # 將x賦值為0
for i in tl:
 i.start()       # 依次運行線程

                                                       
運行結果    
[root@localhost ~]# python syn.py
    
30
30
30
30
30
30
30
30
30
30

由于x是全局變量（共享資源），每個線程對x操作后就休眠了
在線程休眠的時候其他線程也都開始執行操作，
最終休眠5秒后x的值最終就被修改為30了

使用互斥鎖來保護公共資源。用互斥鎖來保證同一時刻只有一個線程訪問公共資源,實現簡單的同步
互斥鎖：threading.Lock
互斥鎖方法：acquire() 獲取鎖   release():釋放鎖
當有一個線程獲的鎖之后，這把鎖就會進入locke狀態（被鎖起來了），另外的線程試圖獲取鎖的時候就會變成同步阻塞狀態，
當擁有線程鎖的的線程調用鎖方法 release()之后就會釋放鎖，那么鎖就會變成開鎖unlocked狀態，之后再從同步阻塞狀態的線程中選擇一個來獲得鎖    
import threading       # 導入threading模塊
import time        # 導入time模塊
class mythread(threading.Thread):     # 通過繼承創建類
 def __init__(self,threadname):     # 初始化方法
  threading.Thread.__init__(self,name = threadname)
 def run(self):       # 重載run方法
  global x      # 使用global表明x為全局變量
  lock.acquire()      # 調用lock的acquire方法
  for i in range(3):
   x = x + 1
  time.sleep(2)   # 調用sleep函數，讓線程休眠5秒
  print x
  lock.release()    # 調用lock的release方法
lock = threading.Lock()    # 類實例化
tl = []       # 定義列表
for i in range(10):
 t = mythread(str(i))   # 類實例化
 tl.append(t)    # 將類對象添加到列表中
        
x=0      # 將x賦值為0
for i in tl:
 i.start()      # 依次運行線程

                          
運行結果：    
[root@localhost ~]# python syn.py    
3
6
9
12
15
18
21
24
27
30

可重入鎖：threading.RLock()
方法和互斥鎖一樣。
假設一個鎖嵌套的情況：有個線程以及獲取到鎖和共享資源了，但是又需要一把鎖來獲取另外一個資源，那么只要把代碼里面的：    
lock = threading.Lock()
修改為：    
lock = threading.RLock()