Python Thread related

1.Thread.join([timeout])

Wait until the thread terminates. This blocks the calling thread until the thread whose join() method is called terminates – either normally or through an unhandled exception – or until the optional timeout occurs.

等待进程结束。也就是说，其屏蔽调用线程，直到此线程方法终止（要么正常执行完毕，或者未处理的异常，或者时间超时）

下面通过例子来说明：

没有设定timeout情况，Main 线程启动，work1 和work2 线程执行，完毕退出，Main线程执行终止

 import os
 import threading
 import time
 import logging
 import random

 def work1():
     count=0
     while count<=5:
         threadname= threading.currentThread()
         wait_time=random.randrange(1,4)
         print("%s,count =%s wait for =%s s,time %s "%(threadname,count,wait_time,time.ctime()[-13:]))
         time.sleep(wait_time)
         count +=1

 def work2():
     i=0
     while i<=5:
         threadname= threading.currentThread()
         wait_time=random.randrange(1,4)
         print("%s,i     =%s wait for =%s s,time %s "%(threadname,i,wait_time,time.ctime()[-13:]))
         time.sleep(wait_time)
         i +=1

 if __name__ =="__main__":
     mainthread= threading.currentThread()
     print '%s main thread is waiting for exit'% mainthread
     test1=threading.Thread(name='work1',target=work1)
     test2=threading.Thread(name='work2',target=work2)
     test1.start()
     test2.start()
     test1.join()
     test2.join()
     print 'main thread finish'

2个线程设定超时时间work1 5s,work2 4s，9s之后调用线程结束而不等待超时的线程：

 import os
 import threading
 import time
 import logging
 import random

 def work1():
     count=0
     while count<=5:
         threadname= threading.currentThread()
         wait_time=random.randrange(1,4)
         print("%s,count =%s wait for =%s s,time %s "%(threadname,count,wait_time,time.ctime()[-13:]))
         time.sleep(wait_time)
         count +=1

 def work2():
     i=0
     while i<=5:
         threadname= threading.currentThread()
         wait_time=random.randrange(1,4)
         print("%s,i     =%s wait for =%s s,time %s "%(threadname,i,wait_time,time.ctime()[-13:]))
         time.sleep(wait_time)
         i +=1

 if __name__ =="__main__":
     mainthread= threading.currentThread()
     print '%s main thread is waiting for exit'% mainthread
     test1=threading.Thread(name='work1',target=work1)
     test2=threading.Thread(name='work2',target=work2)
     test1.start()
     test2.start()
     test1.join(4)
     test2.join(5)
     print 'main thread finish

 2.Producer and comsumer

 import Queue
 import threading
 import random

 #writelock =threading.Lock()
 class Producer(threading.Thread):
     def __init__(self,q,con,name):
         super(Producer,self).__init__()
         self.q = q
         self.con = con
         self.name = name
         print "produce" +self.name+"started"
     def run(self):
         while 1:
             #global writelock
             self.con.acquire()#acquire the lock
             if self.q.full():#if queue is full
                #with writelock:#output info
                print "queue is full, producer wait"
                self.con.wait()#wait for resource
             else:
                 value = random.ranint(0,10)
                 #with writelock:
                 print self.name+"put value"+self.name+":"+str(value)+"into queue"
             self.q.put((self.name+":"+str(value)))#put to queue
             self.con.notify()#inform consumer
         self.con.release()#release the lock

 class Consumer(threading.Thread):
     def __init__(self,q,con,name):
         super(Consumer,self).__init__()
         self.q = q
         self.con = con
         self.name = name
         print "consume" +self.name+"started\n"
     def run(self):
         while 1:
             #global writelock
             self.con.acquire()
             if self.q.empty():#if empty
                 #with writelock:
                 print "queue is empty,consumer wait"
                 self.con.wait()#wait the resource ready
             else:
                 value = self.q.get()#get one element from queue
                 #with writelock:
                 print self.name +"get value"+ value+"from queue"
                 self.q.notify()#inform producer
             self.con.release()#release the lock

 if __name__ == "__main__":
     print "start to run\n"
     q = Queue.Queue(10)
     con = threading.Condition()
     p = Producer(q,con,"p1")
     p.start()
     p1 = Producer(q,con,"p2")
     p1.start()
     c1 = Consumer(q,con,"c1")
     c1.start()

3.Queue

programming python 4th 205页

Queue 提供标准的队列数据结构，实现python对象的先进先出，其可包含基本类型（string，list，dictionary......），类实例，任何可调用函数或绑定的方法等。但是Queue不像正常的list，因为其自动被线程获取和释放锁操作。

#coding:utf-8"
import logging,threading,time
import Queue

def fibo_task(cond):
    with cond:
        while shared_queue.empty():
            logger.info("[%s]- waiting for element in queue......" % threading.current_thread().name)
            cond.wait()
        else:
            value =shared_queue.get()
            a,b=0,1
            for item in range(value):
                a,b=b,a+b
                fibo_dict[value] = a
        shared_queue.task_done()
        time.sleep(2)
        logger.debug("[%s] fibo of key[%d] with result[%d]" % (threading.current_thread().name,value,fibo_dict[value]))

def queue_task(cond):
    logging.debug('starting  list data to queue......')
    with cond:
        for data in impit_list:
            shared_queue.put(data)
        #[shared_queue.put(data) for data in  impit_list]
        cond.notifyAll()

if __name__ == "__main__":
    logger =logging.getLogger()
    logger.setLevel(logging.DEBUG)
    formatter =logging.Formatter('%(asctime)s =%(message)s')

    ch=logging.StreamHandler()
    ch.setLevel(logging.DEBUG)
    ch.setFormatter(formatter)
    logger.addHandler(ch)
    fibo_dict={}
    shared_queue =Queue.Queue()
    impit_list =[3,10,5,7]
    queue_cond=threading.Condition()
    print "main thread starting......"
    threads =[threading.Thread(target=fibo_task,args=(queue_cond,)) for i in range(4)]
    #for thread in threads:
        #thread.setDaemon(True)
        #print 'daemon is %d' % thread.isDaemon()

    [thread.start() for thread in threads]

    prod = threading.Thread(name='queue_task_thread',target=queue_task,args=(queue_cond,))
    prod.setDaemon(True)
    prod.start()

    [thread.join() for thread in threads]
    print "main thread done"