python thread(communicate, join,queue) practices

http://www.cnblogs.com/holbrook/archive/2012/02/23/2365420.html

"""
python多线程编程(7):线程间通信

很多时候，线程之间会有互相通信的需要。常见的情形是次要线程为主要线程执行特定的任务，在执行过程中需要不断报告执行的进度情况。前面的条件变量同步已经涉及到了线程间的通信（threading.Condition的notify方法）。更通用的方式是使用threading.Event对象。
threading.Event可以使一个线程等待其他线程的通知。其内置了一个标志，初始值为False。线程通过wait()方法进入等待状态，直到另一个线程调用set()方法将内置标志设置为True时，Event通知所有等待状态的线程恢复运行。还可以通过isSet()方法查询Envent对象内置状态的当前值。

import threading
import random
import time

class MyThread(threading.Thread):
  def __init__(self, threadName, event):
    threading.Thread.__init__(self,name=threadName)
    self.threadEvent=event

  def run(self):
    print '%s is ready'%self.name
    self.threadEvent.wait()
    print '%s run!' %self.name

sinal=threading.Event()


sinal.set()


for i in range(10):
  t=MyThread(str(i),sinal)
  t.start()


sinal.set()
"""

"""python的Thread类中还提供了join()方法，使得一个线程可以等待另一个线程执行结束后再继续运行。这个方法还可以设定一个timeout参数，避免无休止的等待。因为两个线程顺序完成，看起来象一个线程，所以称为线程的合并.对于sleep时间过长的线程，将不被等待。
import threading
import random
import time

class MyThread(threading.Thread):
  def run(self):
    wait_time=random.randrange(1,10)
    print '%s will wait %d seconds'%(self.name,wait_time)
    time.sleep(wait_time)
    print '%s wakes up!' %self.name

if __name__=='__main__':
  threads=[]
  for i in range(5):
    t=MyThread()
    t.start()
    threads.append(t)

  print 'main thread is waiting for exit...'
 
  for t in threads:
    t.join(1)

  print 'main thread finished!'


后台线程

默认情况下，主线程在退出时会等待所有子线程的结束。如果希望主线程不等待子线程，而是在退出时自动结束所有的子线程，就需要设置子线程为后台线程(daemon)。方法是通过调用线程类的setDaemon()方法。如下：
import threading
import random
import time

class MyThread(threading.Thread):
  def run(self):
    wait_time=random.randrange(1,10)
    print '%s will wait %d seconds'%(self.name,wait_time)
    time.sleep(wait_time)
    print '%s finished!' %self.name

if __name__=='__main__':
  print 'main thread is waitting for exit.....'

  for i in range(5):
    t=MyThread()
    t.setDaemon(True)
    t.start()

  print 'main thread finished!'
"""

"""
python多线程编程(6): 队列同步

前面介绍了互斥锁和条件变量解决线程间的同步问题，并使用条件变量同步机制解决了生产者与消费者问题。

让我们考虑更复杂的一种场景：产品是各不相同的。这时只记录一个数量就不够了，还需要记录每个产品的细节。很容易想到需要用一个容器将这些产品记录下来。

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

用FIFO队列实现上述生产者与消费者问题的代码如下：

import threading
import time
from Queue import Queue

class Producer(threading.Thread):

  def run(self):
    global queue
    count=0
    while True:
      for i in range(100):
        if queue.qsize()>1000:
          pass
        else:
          count=count+1
          msg='produce '+str(count)
          queue.put(msg)
          print msg
        time.sleep(1)

class Consumer(threading.Thread):
  def run(self):
    global queue
    while True:
      for i in range(3):
        if queue.qsize()<100:
          pass
        else:
          msg=self.name+'consume '+ queue.get()
          print msg
        time.sleep(1)

queue=Queue()

def test():
  for i in range(500):
    queue.put('product '+ str(i))
  print 'finished'
  for i in range(2):
    p=Producer()
    p.start()
  for i in range(5):
    c=Consumer()
    c.start()

if __name__=='__main__':
  test()
"""