python thread(communicate, join,queue) practices

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

"""
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()
"""