【转】Python多线程学习

 一、Python 中的线程使用：

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

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

import time  
import thread  
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(): #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 是可选参数。

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

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

import threading
import time
class 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 类的方法，线程的控制可以由自己定制。

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

     此外 threading 模块本身也提供了很多方法和其他的类，可以帮助我们更好的使用和管理线程。可以参看 http://www.python.org/doc/2.5.2/lib/module-threading.html 。

假设两个线程对象 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 thread
import time
mylock = thread.allocate_lock()  #Allocate a lock
num=0  #Shared resource

def 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 threading
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 '/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() 方法以防万一。

生产者与消费者问题是典型的同步问题。这里简单介绍两种不同的实现方法。

1，   条件变量

import threading

import time

class Producer(threading.Thread):

    def __init__(self, t_name):

        threading.Thread.__init__(self, name=t_name)

 

    def run(self):

        global x

        con.acquire()

        if x > 0:

            con.wait()

        else:

            for i in range(5):

                x=x+1

                print "producing..." + str(x)

            con.notify()

        print x

        con.release()

 

class Consumer(threading.Thread):

    def __init__(self, t_name):

        threading.Thread.__init__(self, name=t_name)

    def run(self):

        global x

        con.acquire()

        if x == 0:

            print 'consumer wait1'

            con.wait()

        else:

            for i in range(5):

                x=x-1

                print "consuming..." + str(x)

            con.notify()

        print x

        con.release()

 

con = threading.Condition()

x=0

print 'start consumer'

c=Consumer('consumer')

print 'start producer'

p=Producer('producer')

 

p.start()

c.start()

p.join()

c.join()

print x

 

   上面的例子中，在初始状态下， Consumer 处于 wait 状态， Producer 连续生产（对 x 执行增 1 操作） 5 次后， notify 正在等待的 Consumer 。 Consumer 被唤醒开始消费（对 x 执行减 1 操作）

2，   同步队列

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

生产者将数据依次存入队列，消费者依次从队列中取出数据。

# producer_consumer_queue

from Queue import Queue

import random

import threading

import time

 

#Producer thread

class Producer(threading.Thread):

    def __init__(self, t_name, queue):

        threading.Thread.__init__(self, name=t_name)

        self.data=queue

    def run(self):

        for i in range(5):

            print "%s: %s is producing %d to the queue!/n" %(time.ctime(), self.getName(), i)

            self.data.put(i)

            time.sleep(random.randrange(10)/5)

        print "%s: %s finished!" %(time.ctime(), self.getName())

 

#Consumer thread

class Consumer(threading.Thread):

    def __init__(self, t_name, queue):

        threading.Thread.__init__(self, name=t_name)

        self.data=queue

    def run(self):

        for i in range(5):

            val = self.data.get()

            print "%s: %s is consuming. %d in the queue is consumed!/n" %(time.ctime(), self.getName(), val)

            time.sleep(random.randrange(10))

        print "%s: %s finished!" %(time.ctime(), self.getName())

 

#Main thread

def main():

    queue = Queue()

    producer = Producer('Pro.', queue)

    consumer = Consumer('Con.', queue)

    producer.start()

    consumer.start()

    producer.join()

    consumer.join()

    print 'All threads terminate!'

 

if __name__ == '__main__':

    main()

 

在上面的例子中， Producer 在随机的时间内生产一个“产品”，放入队列中。 Consumer 发现队列中有了“产品”，就去消费它。本例中，由于 Producer 生产的速度快于 Consumer 消费的速度，所以往往 Producer 生产好几个“产品”后， Consumer 才消费一个产品。

Queue 模块实现了一个支持多 producer 和多 consumer 的 FIFO 队列。当共享信息需要安全的在多线程之间交换时， Queue 非常有用。 Queue 的默认长度是无限的，但是可以设置其构造函数的 maxsize 参数来设定其长度。 Queue 的 put 方法在队尾插入，该方法的原型是：

put(  item[, block[, timeout]])

如果可选参数 block 为 true 并且 timeout 为 None （缺省值），线程被 block ，直到队列空出一个数据单元。如果 timeout 大于 0 ，在 timeout 的时间内，仍然没有可用的数据单元， Full exception 被抛出。反之，如果 block 参数为 false （忽略 timeout 参数）， item 被立即加入到空闲数据单元中，如果没有空闲数据单元， Full exception 被抛出。

Queue 的 get 方法是从队首取数据，其参数和 put 方法一样。如果 block 参数为 true 且 timeout 为 None （缺省值），线程被 block ，直到队列中有数据。如果 timeout 大于 0 ，在 timeout 时间内，仍然没有可取数据， Empty exception 被抛出。反之，如果 block 参数为 false （忽略 timeout 参数），队列中的数据被立即取出。如果此时没有可取数据， Empty exception 也会被抛出。