Python多线程学习

         Python代码代码的执行由python虚拟机（也叫解释器主循环）来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行，就像单CPU的系统中运行多个进程那样，内存中可以存放多个程序，但任意时候，只有一个程序在CPU中运行。同样，虽然python解释器可以“运行”多个线程，但在任意时刻，只有一个线程在解释器中运行。(据说新版本有考虑)

        python支持多线程主要是通过thread和threading这两个模块来实现的。thread是比较底层的模 块，threading是对thread做了一些包装的，可以更加方便的被使用。threading模块里面主要是对一些线程的操作对象化了，创建了叫Thread的class。

        其中Thread类是你主要的运行对象，它有很多函数，用它你可以用多种方法来创建线程，常用的为以下三种。 1.创建一个Thread的实例，传给它一个函数（thread和threading两种模块的实现）；2. 创建一个Thread实例，传给它一个可调用的类对象； 3.从Thread派生出一个子类，创建一个这个子类的实例。

1、  函数式：

调用thread模块中的start_new_thread()函数来产生新线程。如下例：

import timeimport threaddef 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(): #Use thread.start_new_thread() to create 2 new threads    thread.start_new_thread(timer, (1,1))    thread.start_new_thread(timer, (2,2)) if __name__=='__main__':    test()

       上面的例子定义了一个线程函数timer,它打印出10条时间记录后退出，每次打印的间隔由interval参数决定。thread.start_new_thread(function, args[, kwargs])的第一个参数是线程函数（本例中的timer方法），第二个参数是传递给线程函数的参数，它必须是tuple类型，kwargs是可选参数。

PS:tuple是python中一个相对简单的类型，它的特点是：有顺序的、不可变的。因此，很显然地tuple有像list和string一样的 indexing和slicing（分片）的功能，可以通过标号对成员进行访问。同时由于tuple是不可变的，因此试图改变tuple成员的是非法的。

        线程的结束可以等待线程自然结束，也可以在线程函数中调用thread.exit()或thread.exit_thread()方法。

创建Thread实例，传递一个函数给它：

import threadingfrom time import sleep,ctimeloops=[4,2]def loop(nloop,nsec):       print 'start loop',nloop,'at:',ctime()       sleep(nsec)       print 'loop',nloop,'done at:',ctime()def main():       print 'starting at:',ctime()       threads=[]       nloops=range(len(loops))       for i in nloops:              t=threading.Thread(target=loop,args=(i,loops[i]))              threads.append(t)       for i in nloops:              threads[i].start()       for i in nloops:              threads[i].join()                  print 'all done at:',ctime()     if __name__=='__main__':       main()

2、 传递类对象：创建一个实例，传递一个可调用的类的对象

 import threadingfrom time import sleep,ctimeloops=[4,2]class ThreadFunc(object):       def __init__(self,func,args,name=''):              self.name=name              self.func=func              self.args=args       def __call__(self):              self.res=self.func(*self.args)def loop(nloop,nsec):       print 'start loop',nloop,'at:',ctime()       sleep(nsec)       print 'loop',nloop,'done at:',ctime()def main():       print 'starting at:',ctime()       threads=[]       nloops=range(len(loops))       for i in nloops:              t=threading.Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__))              threads.append(t)       for i in nloops:              threads[i].start()       for i in nloops:              threads[i].join()       print 'all done at:',ctime()if __name__=='__main__':       main()

3、 创建threading.Thread的子类来包装一个线程对象，如下例：

import threadingimport timeclass timer(threading.Thread): #The timer class is derived from the class threading.Thread    def __init__(self, num, interval):        threading.Thread.__init__(self)        self.thread_num = num        self.interval = interval        self.thread_stop = False     def run(self): #Overwrite run() method, put what you want the thread do here        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():    thread1 = timer(1, 1)    thread2 = timer(2, 2)    thread1.start()    thread2.start()    time.sleep(10)    thread1.stop()    thread2.stop()    return if __name__ == '__main__':    test()

threading.Thread类的使用：

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()，检查线程是否在运行中。

    假设两个线程对象t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。但是由于是多线程访问，有可能出现下面情况：在num=0时，t1取得num=0。系统此时把t1调度为”sleeping”状态，把t2转换为”running”状态，t2页获得num=0。然后t2对得到的值进行加1并赋给num，使得num=1。然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num=1。

    上面的case描述了多线程情况下最常见的问题之一：数据共享。当多个线程都要去修改某一个共享数据的时候，我们需要对数据访问进行同步。

1、  简单的同步

   最简单的同步机制就是“锁”。锁对象由threading.RLock类创建。线程可以使用锁的acquire()方法获得锁，这样锁就进入“locked”状态。每次只有一个线程可以获得锁。如果当另一个线程试图获得这个锁的时候，就会被系统变为“blocked”状态，直到那个拥有锁的线程调用锁的release()方法来释放锁，这样锁就会进入“unlocked”状态。“blocked”状态的线程就会收到一个通知，并有权利获得锁。如果多个线程处于“blocked”状态，所有线程都会先解除“blocked”状态，然后系统选择一个线程来获得锁，其他的线程继续沉默（“blocked”）。

Python中的thread模块和Lock对象是Python提供的低级线程控制工具，使用起来非常简单。如下例所示：

import threadimport timemylock = thread.allocate_lock()  #Allocate a locknum=0  #Shared resourcedef add_num(name):    global num    while True:        mylock.acquire() #Get the lock         # Do something to the shared resource        print 'Thread %s locked! num=%s'%(name,str(num))        if num >= 5:            print 'Thread %s released! num=%s'%(name,str(num))            mylock.release()            thread.exit_thread()        num+=1        print 'Thread %s released! num=%s'%(name,str(num))        mylock.release()  #Release the lock.def test():    thread.start_new_thread(add_num, ('A',))    thread.start_new_thread(add_num, ('B',))if __name__== '__main__':    test()

    Python 在thread的基础上还提供了一个高级的线程控制库，就是之前提到过的threading。Python的threading module是在建立在thread module基础之上的一个module，在threading module中，暴露了许多thread module中的属性。在thread module中，python提供了用户级的线程同步工具“Lock”对象。而在threading module中，python又提供了Lock对象的变种: RLock对象。RLock对象内部维护着一个Lock对象，它是一种可重入的对象。对于Lock对象而言，如果一个线程连续两次进行acquire操作，那么由于第一次acquire之后没有release，第二次acquire将挂起线程。这会导致Lock对象永远不会release，使得线程死锁。RLock对象允许一个线程多次对其进行acquire操作，因为在其内部通过一个counter变量维护着线程acquire的次数。而且每一次的acquire操作必须有一个release操作与之对应，在所有的release操作完成之后，别的线程才能申请该RLock对象。

下面来看看如何使用threading的RLock对象实现同步。

import threadingmylock = 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 '/nThread(%s) locked, Number: %d'%(self.t_name, num)            if num>=4:                mylock.release()                print '/nThread(%s) released, Number: %d'%(self.t_name, num)                break            num+=1            print '/nThread(%s) released, Number: %d'%(self.t_name, num)            mylock.release()            def test():    thread1 = myThread('A')    thread2 = myThread('B')    thread1.start()    thread2.start() if __name__== '__main__':    test()

我们把修改共享数据的代码成为“临界区”。必须将所有“临界区”都封闭在同一个锁对象的acquire和release之间。

2、  条件同步

    锁只能提供最基本的同步。假如只在发生某些事件时才访问一个“临界区”，这时需要使用条件变量Condition。

Condition对象是对Lock对象的包装，在创建Condition对象时，其构造函数需要一个Lock对象作为参数，如果没有这个Lock对象参数，Condition将在内部自行创建一个Rlock对象。在Condition对象上，当然也可以调用acquire和release操作，因为内部的Lock对象本身就支持这些操作。但是Condition的价值在于其提供的wait和notify的语义。

    条件变量是如何工作的呢？首先一个线程成功获得一个条件变量后，调用此条件变量的wait()方法会导致这个线程释放这个锁，并进入“blocked”状态，直到另一个线程调用同一个条件变量的notify()方法来唤醒那个进入“blocked”状态的线程。如果调用这个条件变量的notifyAll()方法的话就会唤醒所有的在等待的线程。

    如果程序或者线程永远处于“blocked”状态的话，就会发生死锁。所以如果使用了锁、条件变量等同步机制的话，一定要注意仔细检查，防止死锁情况的发生。对于可能产生异常的临界区要使用异常处理机制中的finally子句来保证释放锁。等待一个条件变量的线程必须用notify()方法显式的唤醒，否则就永远沉默。保证每一个wait()方法调用都有一个相对应的notify()调用，当然也可以调用notifyAll()方法以防万一。

参考地址：

http://blog.sina.com.cn/s/blog_7a9c930d01015ueb.html

http://www.cnblogs.com/tqsummer/archive/2011/01/25/1944771.html

http://www.oschina.net/code/snippet_16840_1815

http://hi.baidu.com/msingle/item/969dc61e2590e9fb65eabfb6

http://www.python.org/doc/2.5.2/lib/module-threading.html