1. 線程狀態(tài)
   新建冶匹，就緒习劫，運行，阻塞嚼隘，死亡诽里。
2. 線程同步
   多線程可以同時運行多個任務，線程需要共享數(shù)據(jù)的時候飞蛹，可能出現(xiàn)數(shù)據(jù)不同步的問題谤狡，用最習慣的LabVIEW來說灸眼，多線程中的2個循環(huán)如果一個對數(shù)組進行寫入，另一個進行讀取墓懂，就有可能導致還沒寫入就要讀取焰宣，為了避免這種情況，就要給線程加鎖捕仔。
   鎖有兩種狀態(tài)－鎖定和未鎖定匕积。每當一個線程要訪問共享數(shù)據(jù)的時候，必須先獲得鎖定榜跌，如果有別的線程已經(jīng)獲得鎖定了闪唆，那么該線程就得暫停，這個稱之為同步阻塞钓葫。等到另外的線程訪問完畢之后悄蕾，釋放鎖，該線程才能繼續(xù)訪問础浮。
3. 線程通信
   另外一種可能就是數(shù)組還沒有創(chuàng)建帆调，寫入線程和讀取線程肯定不能運行，所以必須等待創(chuàng)建線程的通知豆同。所以引入了條件變量番刊。
   條件變量允許線程在條件不滿足的時候等待，條件滿足的時候開始運行影锈。
4. 線程運行和阻塞的狀態(tài)轉(zhuǎn)換
   同步阻塞指處于競爭鎖定的狀態(tài)撵枢，線程請求鎖定時進入這個狀態(tài)，一旦成功獲得鎖定時又恢復到運行狀態(tài)精居。
   等待阻塞是指等待其他線程通知的狀態(tài)锄禽，線程獲得條件鎖定后，調(diào)用等待將進入這個狀態(tài)靴姿，一旦其他線程發(fā)出通知沃但，線程將進入同步阻塞狀態(tài)，再次競爭條件鎖定佛吓。
   其他阻塞是指調(diào)用time.sleep(),anotherthread.join()或者等待IO時的阻塞宵晚，這個狀態(tài)下線程不會釋放已獲得的鎖定。
5. thread模塊

import thread
import time
#在線程中執(zhí)行的函數(shù)
def func():
    for i in range(5):
        print 'func'
        time.sleep(1)
    #結(jié)束當前線程
    thread.exit()
    #與thread.exit_thread()等價
    #func返回的時候,線程同樣會結(jié)束
#啟動線程,線程立即開始運行
thread.start_new(func,())
#這個方法和thread.start_new_thread()等價
#第一個參數(shù)是方法,第二個參數(shù)是方法的參數(shù),如果沒有參數(shù),傳入空的元組
#創(chuàng)建鎖
lock = thread.allocate()
#這個方法和thread.allocate_lock()等價
#判斷鎖的狀態(tài),鎖定還是釋放
print lock.locked()
#鎖通常用于控制對共享資源的訪問
count = 0
#獲得鎖,成功獲得鎖定后返回True
#可選的timeout參數(shù)不填將一直阻塞到獲得鎖定
#否則超時后返回False
if lock.acquire():
    print "True"
    count += 1
    #釋放鎖
    lock.release()
#thread模塊提供的線程都在主線程結(jié)束后同時結(jié)束
time.sleep(6)```
`thread.interrupt_main()`:在其他線程中終止主線程维雇。
6. threading模塊
鎖Lock和條件變量Condition在Python中是獨立對象淤刃。
`threading.currentThread()`:返回當前的線程變量
`threading.enumerate()`:返回一個正在運行的線程的list，指線程啟動后吱型，結(jié)束前逸贾。
`threading.activeCount()`:返回正在運行的線程數(shù)量,`len(threading.enumerate())`有相同的結(jié)果。
threading提供的類，Thread,Lock,Rlock,Condition,[Bounded]Semaphore,Event,Timer,local
  1. Thread

import threading

開啟線程,將要執(zhí)行的函數(shù)作為參數(shù)傳給Thread的構(gòu)造方法

def func():
print "func() passed to Thread"
t = threading.Thread(target=func)
t.start()

從Thread繼承,重寫run(),在線程開始運行的時候就會運行run

class MyThread(threading.Thread):
def run(self):
print "MyThread extended from Thread"
t = MyThread()
t.start()```
isAlive():返回線程是否在運行铝侵。
get/setName(name):獲茸粕恕／設置線程名
is/setDaemon(bool):獲取／設置是否守護線程
start()啟動線程
join([timeout]):阻塞當前上下文的線程咪鲜，直到調(diào)用此方法的線程終止或者到達指定的timeout

#join()的一個用法
import threading
import time
def context(tJoin):
        print "in threadContext"
        #啟動參數(shù)傳遞過來的線程
        tJoin.start()
        #阻塞tContext直到thread tJoin線程終止
        tJoin.join()
        #tJoin結(jié)束后繼續(xù)運行
        print "out threadContext"
def joinfunc():
        print "in threadJoin"
        time.sleep(4)
        print 'out threadJoin'
#創(chuàng)建線程tJoin,在tContext線程中運行,然后阻塞tContext
#tJoin運行完之后,繼續(xù)tContext線程
tjoin = threading.Thread(target=joinfunc)
tContext = threading.Thread(target=context,args=(tjoin,))
tContext.start()```
  2. Lock
Lock指令鎖是可用的最低級的同步指令狐赡，Lock處于鎖定狀態(tài)時候，不被特定的線程擁有疟丙，Lock包含兩種狀態(tài)鎖定和非鎖定颖侄，以及兩個基本方法舆绎。
可以認為Lock又一個鎖定池酝静，當線程請求鎖定時，將線程置于池中炒考，直到獲得鎖定后出池拂蝎。池中的線程處于同步阻塞的狀態(tài)。
acquire([timeout])使得線程進入同步阻塞狀態(tài)惶室，嘗試獲得鎖定,也就是用在哪個線程温自，哪個線程就處于阻塞，直到獲得鎖定皇钞，獲得鎖定后需要釋放鎖
release()釋放鎖悼泌，使用前當前線程必須已經(jīng)獲得鎖定

import threading
import time
data = 0
lock = threading.Lock()
def func():
global data
print "%s acquire lock..."% threading.currentThread().getName()
#調(diào)用acquire()時候,線程一直阻塞,直到獲得鎖定
#返回是否獲得鎖
if lock.acquire():
print "%s get the lock"% threading.currentThread().getName()
data += 1
time.sleep(2)
print "%s release lock..."%threading.currentThread().getName()
lock.release()
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t3 = threading.Thread(target=func)
t1.start()
t2.start()
t3.start()```
終于弄懂了Lock()這塊，acquire(),release()的用法

3. RLock
   RLock可重入鎖是一個可以被同一個線程請求多次的同步指令夹界，處于鎖定狀態(tài)時馆里，RLock被某個線程擁有，擁有RLock的線程可以在此調(diào)用acquire(),釋放鎖的時候需要調(diào)用release()相同次數(shù)可柿。
   可以認為RLock包含一個鎖定池和一個初始值為0的計數(shù)器鸠踪，每次成功調(diào)用acquire()/release()，計數(shù)器加一或者減一复斥，為0的時候鎖處于未鎖定狀態(tài)营密。

import threading
import time
rlock = threading.RLock()
def func():
       #第一次請求鎖定
       print '%s acquire lock..'%threading.currentThread().getName()
       if rlock.acquire():
           print "%s get the lock"%threading.currentThread().getName()
           time.sleep(2)
           #第二次請求鎖定
           print "%s acquire lock again.."%threading.currentThread().getName()
           if rlock.acquire():
               print "%s get the lock"%threading.currentThread().getName()
               time.sleep(2)
           #第一次釋放鎖
           print "%s release lock "%threading.currentThread().getName()
           rlock.release()
           time.sleep(2)
           #第二次釋放鎖
           print "%s release lock "%threading.currentThread().getName()
           rlock.release()
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t3 = threading.Thread(target=func)
t1.start()
t2.start()
t3.start()```
 4. Condition
Condition通常和一個鎖關(guān)聯(lián)，需要在多個Condition中共享一個鎖時目锭，可以傳遞一個Lock/RLock實例給構(gòu)造方法评汰，否則它將自己生成一個RLock實例
除了Lock帶有的鎖定池外，Condition還包含一個等待池痢虹，池中的線程處于等待阻塞狀態(tài)被去，直到另一個線程調(diào)用notify()/notifyAll()通知，得到通知后線程進入鎖定池等待鎖定奖唯。
acquire()/release()：調(diào)用關(guān)聯(lián)的鎖的相應方法
wait():調(diào)用這個方法將使線程進入Condition的等待池等待通知惨缆，并且釋放鎖。使用前線程必須已經(jīng)獲得鎖定。
notify()調(diào)用這個方法將從等待池中挑選一個線程并且通知踪央，收到通知的線程將自動調(diào)用acquire()嘗試獲得鎖定臀玄。其他線程仍然在等待池中，調(diào)用這個方法不回釋放鎖定畅蹂，使用前線程已獲得鎖定健无。
notifyAll()調(diào)用這個方法將通知等待池中所有線程，這些線程都將進入鎖定池嘗試獲得鎖定液斜，調(diào)用這個方法不會釋放鎖定累贤，使用前必須已獲得鎖定。
這兩個方法都是用于已經(jīng)獲得鎖定的線程少漆。

import threading
import time
product = None
con = threading.Condition()

生產(chǎn)者方法

def produce():
global product
#該進程獲得鎖
if con.acquire():
while True:
if product is None:
print "produce..."
product = "anything"
#通知消費者,商品已經(jīng)生產(chǎn)
con.notify()
#使得這個線程進入等待阻塞,并且釋放鎖
con.wait()
time.sleep(2)

消費者

def consume():
global product
#嘗試該線程加鎖
if con.acquire():
while True:
if product is not None:
print "consume..."
product = None
#通知
con.notify()
con.wait()
time.sleep(2)
t1 = threading.Thread(target=produce)
t2 = threading.Thread(target=consume)
t2.start()
t1.start()```
很有意思的小程序啊

5. Semaphore/BoundedSemaphore
   信號量臼膏，管理一個內(nèi)置的計數(shù)器，每當調(diào)用acquire()時候－1示损，調(diào)用release()時候＋1渗磅，計數(shù)器不能小于0.當計數(shù)器為0時候，acquire()將阻塞線程至同步鎖定狀態(tài)检访，直到其他線程調(diào)用release()
   Semaphore經(jīng)常來同步一些油訪客上限的對象始鱼，如連接池。
   BoundedSemaphore與Semaphore的唯一區(qū)別是前者將在調(diào)用release()時候檢查計數(shù)器的值是否超過了計數(shù)器的初始值脆贵。
   Semaphore(value=1):value是計數(shù)器的初始值医清。
   acquire()請求Semaphore，如果計數(shù)器為0卖氨，將阻塞線程至同步阻塞狀態(tài)会烙，否則將計數(shù)器－1并立即返回
   release()釋放Semaphore，將計數(shù)器+1筒捺，如果使用BoundedSemaphore柏腻，還將進行釋放次數(shù)檢查，release()方法不檢查線程是否已經(jīng)獲得Semaphore

import threading
import time
semaphore = threading.BoundedSemaphore(2)
def func():
        #請求Semaphore,成功后計數(shù)器-1,計數(shù)器為0的時候阻塞
        print "%s acquire semaphore..."%threading.currentThread().getName()
        if semaphore.acquire():
            print "%s get semaphore"%threading.currentThread().getName()
            time.sleep(4)
            #釋放Semaphore,計數(shù)器+1
            print '%s release semaphore'%threading.currentThread().getName()
            semaphore.release()
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t3 = threading.Thread(target=func)
t4 = threading.Thread(target=func)
t1.start()
t2.start()
t3.start()
t4.start()
time.sleep(2)
#沒有獲得semaphore的主線程也可以調(diào)用release
#如果使用BoundedSemaphore,主線程釋放后將拋出異常
print "mainthread release semaphore without acquire"
semaphore.release()```
想起了復習操作系統(tǒng)時候的信號量跋悼浴葫盼！
  6. Event
Event是最簡單的線程通信機制，一個線程通知事件村斟，其他線程等待事件贫导，Event內(nèi)置了一個初始為False的標志，當調(diào)用set()時設為True蟆盹，調(diào)用clear()時重置為False孩灯，wait()將阻塞線程至等待阻塞狀態(tài)。
Event沒有鎖逾滥，無法使線程進入同步阻塞狀態(tài)峰档。
isSet()當內(nèi)置標志為True時候返回True
set()將標志設為True败匹，并且通知所有處于等待阻塞狀態(tài)的線程恢復運行狀態(tài)。
clear()將標志設為False
wait()如果標志為True則立即返回讥巡，否則阻塞線程至等待阻塞狀態(tài)掀亩，等待其他線程調(diào)用set()

import threading
import time
event = threading.Event()
def func():
#等待事件,進入等待阻塞狀態(tài)
print "%s wait for event"%threading.currentThread().getName()
#如果標志為True立即返回,否則阻塞線程至等待阻塞狀態(tài),等待其他線程調(diào)用set()
event.wait()
#收到事件后進入運行狀態(tài)
print "%s recv event"%threading.currentThread().getName()
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t1.start()
t2.start()
time.sleep(2)

發(fā)送事件通知

print "mainthread set event"

將標志設為True,通知所有處于等待阻塞狀態(tài)的線程恢復運行狀態(tài)

event.set()```

7. Timer
   Timer定時器是Thread的派生類，用于在指定時間后調(diào)用一個方法
   Timer(interval,function,args,kwargs)
   interval指定的時間欢顷，function要執(zhí)行的方法

import threading
def func():
        print "hello timer!"
timer = threading.Timer(5,func)
timer.start()```
  8. local
local是一個小寫字母開頭的類槽棍，用于管理線程局部的數(shù)據(jù)，對于同一個local抬驴，線程無法訪問其他線程設置的屬性炼七，線程設置的屬性不會被其他線程設置的同名屬性替換。
可以把local看成一個線程屬性字典的字典布持，local封裝了從自身使用線程作為key檢索對應的屬性字典豌拙，再使用屬性名作為key檢索屬性值的細節(jié)。

import threading
local = threading.local()
local.tname = 'main'
def func():
local.tname = 'not main'
print local.tname
t1 = threading.Thread(target=func)
t1.start()

阻塞主線程,直到t1線程運行完畢

t1.join()
print local.tname```

一個例子

import threading
alist = None
condition = threading.Condition()
def doSet():
    global alist
    print "%s acquire lock"%threading.currentThread().getName()
    if condition.acquire():
        print '%s get lock'%threading.currentThread().getName()
        while alist is None:
            condition.wait()
            print "%s wait notify"%threading.currentThread().getName()
        print "%s get notify"%threading.currentThread().getName()
        for i in range(len(alist))[::-1]:
            alist[i] = i
        print "%s release lock"%threading.currentThread().getName()
        condition.release()
def doPrint():
    global alist
    if condition.acquire():
        while alist is None:
            condition.wait()
        for i in alist:
            print i,
        print
        condition.release()
def doCreate():
    global alist
    if condition.acquire():
        if alist is None:
            alist = [i for i in range(10)]
            condition.notifyAll()
        condition.release()
tset = threading.Thread(target=doSet,name='tset')
tprint = threading.Thread(target=doPrint,name='tprint')
tcreate = threading.Thread(target=doCreate,name='tcreate')
tset.start()
tprint.start()
tcreate.start()```