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的队列。