python多线程学习

python多线程学习：

python中的线程使用的两种方式：函数或者用类来包装线程对象。

1、函数式：调用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()

2、创建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类的使用：

1、在自己的线程类的__inin__()里调用threading.Thread.__init__(self,name=threadname)

2、run()，通常需要重写，编写代码实现所需要的功能。

3、getName(),获得线程对象名称

4、setName()，设置线程对象名称

5、start(),启动线程

6、jion(),等待另一线程的结束后再运行

7、setDaemon(),设置子线程是否随主线程一起结束，必须在start()之前调用。默认为False。

8、isDaemon(),判断线程是否随主线程一起结束。

9、isAlive()，检查线程是否在运行中。

线程同步：数据共享。当多个线程都要去修改某一个共享数据的时候，我们需要对数据访问进行同步。

1、简单同步

最简单的同步机制就是‘锁’。锁对象由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()

2、条件同步

      使用wait()和set()fangfa 进行加锁和释放锁。

      还可以使用队列。Python中的Queue对象也提供了对线程同步的支持。使用Queue对象可以实现多个生产者和多个消费者形成的FIFO的队列。