python多線程學習

python多線程學習：

python中的線程使用的兩種方式：函數或者用類來包裝線程對象。

一、函數式：調用thread模塊中start_new_thread()函數來產生新線程。

#!/usr/bin/env python
#coding:utf-8
'''
會出現一下的錯誤，在pydev中就會出現這樣的錯誤，緣由不明。通常不建議使用
thread這個模塊。
Unhandled exception in thread started by 
sys.excepthook is missing
lost sys.stderr
Unhandled exception in thread started by 
sys.excepthook is missing
lost sys.stderr
'''
import thread
import time
def timer(no,interval):
    cnt = 0
    while cnt<10:
        print 'Thread :(%d) Time:%s\n'%(no,time.ctime())
        time.sleep(interval)
        cnt+=1
    thread.exit_thread()
    
def test():
    thread.start_new_thread(timer,(1,1))
    thread.start_new_thread(timer, (2,2))
    
if __name__=='__main__':
    test()

二、建立threading.Thread 的子類來包裝一個線程對象。

#!/usr/bin/env python
#coding:utf-8
from threading import Thread
import time 
from _ast import Num
class timer(Thread):
    def __init__(self,num,interval):
        Thread.__init__(self)
        self.thread_num = num
        self.interval = interval
        self.thread_stop = False
        
    def run(self):
        while not self.thread_stop:
            print 'Thread Object(%d),Time:%s\n'%(self.thread_num,time.ctime())
            time.sleep(self.interval)
    
    def stop(self):
        self.thread_stop = True
def test():
    t1 = timer(1,1)
    t2 = timer(2,2)
    
    t1.start()
    t2.start()
    time.sleep(10)
    t1.stop()
    t2.stop()
    return 
if __name__=='__main__':
    test()

        

threading.Thread類的使用：

一、在本身的線程類的__inin__()裏調用threading.Thread.__init__(self,name=threadname)

二、run()，一般須要重寫，編寫代碼實現所須要的功能。

三、getName(),得到線程對象名稱

四、setName()，設置線程對象名稱

五、start(),啓動線程

六、jion(),等待另外一線程的結束後再運行

七、setDaemon(),設置子線程是否隨主線程一塊兒結束，必須在start()以前調用。默認爲False。

八、isDaemon(),判斷線程是否隨主線程一塊兒結束。

九、isAlive()，檢查線程是否在運行中。

線程同步：數據共享。當多個線程都要去修改某一個共享數據的時候，咱們須要對數據訪問進行同步。

一、簡單同步

最簡單的同步機制就是‘鎖’。鎖對象由threading.RLock類建立。線程能夠使用鎖的acquire()方法得到鎖，這樣鎖

就進入了「locked」狀態。每次只有一個線程能夠得到鎖。這個線程使用完資源之後調用鎖的release()方法來釋放鎖，使鎖

進入「unlocked」狀態。

python中的thread模塊和Lock對象是python提供的低級線程控制工具，比較簡單。

#!/usr/bin/env python
#coding:utf-8
import threading 
import time
mylock = threading.RLock()
num = 0
class myThread(threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.t_name = name
        
    def run(self):
        global num
        while True:
            mylock.acquire()#獲得鎖
            print 'Thread(%s) locked, Number: %d'%(self.t_name, num)
            if num >=5:
                mylock.release()
                print 'Thread %s release! num =%d'%(self.t_name,num)
                break
            num+=1
            print 'Thread %s released! num = %d'%(self.t_name,num)
            mylock.release()
def test():
    t1 = myThread('A')
    t2 = myThread('B')
    t1.start()
    t2.start()
    
    
if __name__== '__main__': 
    test()

二、條件同步

      使用wait()和set()fangfa 進行加鎖和釋放鎖。

      還能夠使用隊列。Python中的Queue對象也提供了對線程同步的支持。使用Queue對象能夠實現多個生產者和多個消費者造成的FIFO的隊列。