"""" Python中使用線程有兩種方式：函數或用類別來包裝線程物件。
1、 函數式：呼叫thread模組中的start_new_thread()函數來產生新執行緒。執行緒的結束可以等待執行緒自然結束，也可以在執行緒函數中呼叫thread.exit()或thread.exit_thread()方法。
import time
import thread
def timer(no,interval):
cnt=0
while cnt cnt= cnt+1
def test():
thread.start_new_thread(timer,(1,1))
thread.start_new_thread==(timer,(2,2))
thread.start_new_thread==(timer,(2,2))
thread.startname thread starting'
test()
time.sleep(20)
thread.exit_thread()
print 'exit...'
2、 建立一個建立一個子類別的子類別，Threadthread？使用：
1，在自己的線程類別的__init__裡調用threading.Thread.__init__(self, name = threadname)
Threadname為線程的名字
2， run()，通常需要重寫，寫程式碼實現做需要的功能。
3，getName()，取得執行緒物件名稱
4，setName()，設定執行緒物件名稱
5，start()，啟動執行緒
6，jion([timeout])，等待另一個執行緒結束後再運行。
7，setDaemon(bool)，設定子執行緒是否隨主執行緒一起結束，必須在start()之前呼叫。預設為False。
8，isDaemon()，判斷執行緒是否隨主執行緒一起結束。
9，isAlive()，檢查執行緒是否在運作中。
import threading
import time
class timer(threading.Thread):
def __init__(self,num,interval): sel.
self.interval=interval
self .thread_stop=False
def run(self):
while not self.thread_stop:
time.sleep( self.interval)
def stop(self):
self.thread_stop=True
def test(): 我()
thread2.start()
time.sleep(10)
thread1.stop()
thread2.stop()
return
if __name__=='main:
問題產生的原因是沒有控制多個執行緒對相同資源的訪問，對資料造成破壞，使得執行緒運行的結果不可預期。這種現象稱為「線程不安全」。
import threading
import time
class MyThread(threading.Thread):
def run(self):
sg='I am '+ self.getName ()+'@'+str(i)
print msg
def test():
for i in range(5):
__Thread() ':
test()
上面的範例引出了多執行緒程式設計最常見的問題：資料共享。當多個執行緒都修改某一個共享資料的時候，就需要進行同步控制。
執行緒同步能夠確保多個執行緒安全存取競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖為資源引入一個狀態：鎖定/非鎖定。某個執行緒要更改共享資料時，先將其鎖定，此時資源的狀態為“鎖定”，其他執行緒不能更改；直到該執行緒釋放資源，將資源的狀態變成“非鎖定”，其他的執行緒才能再次鎖定該資源。互斥鎖保證了每次只有一個執行緒進行寫入操作，從而保證了多執行緒情況下資料的正確性。其中，鎖定方法acquire可以有一個超時時間的可選參數timeout。如果設定了timeout，則在逾時後透過回傳值可以判斷是否得到了鎖，從而可以進行一些其他的處理
threading模組中定義了Lock類
import threading
import time
class MyThread(threading.Thread ):
def run(self):
global num
time.sleep(1)
if mutex.acquire():
num=num+1
mutex.release()
num=0
mutex=threading.Lock()
def test():
for i in range(5):
t=MyThread() test()
"""
"""更簡單的死鎖情況是一個執行緒「迭代」請求相同資源，直接就會造成死鎖：
import threading
import time
class MyThread(threading.Thread)(threading.Thread) :
def run(self):
global num
num = num+1
msg = self.name+' set num to '+str(num)
print msg
mutex.acquire() mutex.release()
num = 0
mutex = threading.Lock()
def test():
for i in range(5): = MyThread()
t.start()
if __name__ == '__main__':
test()
為了支援在同一執行緒中多次要求相同資源，python」提供了「可重複鎖定了. RLock內部維護一個Lock和一個counter變量，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。上述的例子如果使用RLock代替Lock，則不會發生死鎖：
import threading
import time
class MyThread(threading.Thread):
def run(self): time.sleep(1)
if mutex.acquire(1):
(1): print msg
mutex.acquire()
mutex.release ()
num = 0
mutex = threading.RLock()
def test():
for i in range(5):
__name__ == '__main__':
test()
"""
"""
python多執行緒程式設計(5): 條件變數同步
互斥鎖定是最簡單的執行緒同步問題的支持。 Condition被稱為條件變量，除了提供與Lock類似的acquire和release方法外，還提供了wait和notify方法。線程先acquire一個條件變量，然後再判斷一些條件。如果條件不滿足則wait；如果條件滿足，進行一些處理改變條件後，透過notify方法通知其他線程，其他處於wait狀態的線程接到通知後會重新判斷條件。不斷的重複這個過程，從而解決複雜的同步問題。
可以認為Condition物件維護了一個鎖定（Lock/RLock)和一個waiting池。執行緒透過acquire取得Condition對象，當呼叫wait方法時，執行緒會釋放Condition內部的鎖定並進入blocked狀態，同時在waiting池中記錄這個執行緒。當呼叫notify方法時，Condition物件會從waiting池中挑選一個線程，通知其呼叫acquire方法嘗試取到鎖。
Condition物件的建構子可以接受一個Lock/RLock物件作為參數，如果沒有指定，則Condition物件會在內部自行建立一個RLock。
除了notify方法外，Condition物件還提供了notifyAll方法，可以通知waiting池中的所有執行緒嘗試acquire內部鎖定。由於上述機制，處於waiting狀態的執行緒只能透過notify方法喚醒，所以notifyAll的作用在於防止有執行緒永遠處於沉默狀態。
簡報條件變數同步的經典問題是生產者與消費者問題：假設有一群生產者(Producer)和一群消費者（Consumer）透過一個市場來互動產品。生產者的」策略「是如果市場上剩餘的產品少於1000個，那麼就生產100個產品放到市場上；而消費者的」策略「是如果市場上剩餘產品的數量多餘100個，那麼就消費3個產品。使用Condition解決生產者與消費者問題的代碼如下：
import threading
import time
class Producer(threading.Thread):
if con.acquire() :
if count>1000:
con.wait()
print self.name+' produce 100,count='+str(count)
(1)
class Customer(threading.Thread):
def run(self):
global count
count>100:
count=count-100
print self .name+ 'consume 100, count='+str(count)
else:
time.sleep(1)
count=500
con=threading.Condition()
def test():
for i in range(5):
p=Producer()
p.start()
if __name__==' __main__':
test()
python中預設全域變數在函數中可以讀，但是不能寫但是
對con只讀，所以不用global引入"""
