线程和python

chriszg

　　用锁进行线程的同步例子
　　import thread
from time import sleep,time,ctime
def loop0():
print 'start loop 0 at :',ctime(time())
sleep(3)
print 'end loop 0 at :',ctime(time())

def loop1():
print 'start loop 1 at :',ctime(time())
sleep(1)
print 'end loop 1 at :',ctime(time())
loops = [4,2]
def loop(nloop,nsec,lock):
print 'start loop ',nloop,'at:',ctime(time())
#sleep(nsec)
print 'loop',nloop,'done at:',ctime(time())
lock.release()#每个线程释放自己的锁
def main():
print 'starting threads ...'
locks=[]
nloops = range(len(loops))

for i in nloops:
lock = thread.allocate_lock();
lock.acquire()#为每一个线程分配线程锁
locks.append(lock)

for i in nloops:#让所有的线程同时在这一时间点运行
thread.start_new_thread(loop,(i,loops,locks))
#创建线程运行，语法和apply内建函数是完全一样的，loop函数，函数参数(i,loops,locks)

for i in nloops:
while locks.locked():print 'i am waiting for ->',i
#判断线程是否已经结束
print 'all done at :',ctime(time())
　　/////////////////////////////////////////////////////////////////////////////////////////////////////////
　　对python虚拟机访问是由一个“全局性解释锁”(global interpreter lock)指控的，python虚拟机的执行方式是下面的方式:
.设置GIL
.把一个线程切换到运行状态
.执行一定数量的字节码指令
.把那个线程放回到休眠状态(把线程切换出执行状态)
.解开GIL，然后从头再来
　　thread模块提供了对线程和线程锁的基本支持，threading模块提供了更高水平的全功能的线程管理功能。Queue模块允许用户创建一个能够被多个线程共享的队列数据结构。
　　下面给出创建线程的3种方法:
1)创建Thread实例，传递进一个函数
2)创建Thread实例，传递进可调用类实例
3)从Thread推导子类并创建子类实例
　　1)创建Thread实例，传递进一个函数
#!/usr/bin/env python
import threading
from time import sleep,time,ctime
　　loops=[4,2]
def loop(nloop,nsec):
print 'start loop',nloop,'at:',ctime(time())
sleep(nsec)
print 'loop',nloop,'done at:',ctime(time())

def main():
print 'starting threading ... '
threads = []
nloops = range(len(loops))

for i in nloops:
t = threading.Thread(target=loop,args=(i,loops))
threads.append(t)
　　for i in nloops:#调用每个线程的start()方法让他们一起冲出起跑线
threads.start()

　　for i in nloops:
threads.join()#线程锁也不需要我们的管理了(分配内存，取得，释放，检查各个线程锁状态)
#使用join会等待一个线程的结束，如果进行了相应的设置，也可以等待一个线程超时情况的发生，join显然要比一个等待线程锁被释放的无限循环要清晰的多
#调用join就是让主线程等待其他线程们一起完成
print 'all done at :',ctime(time())
　　

2)创建Thread实例，传递进可调用类实例
#!/usr/bin/env python
import threading
from time import sleep,time,ctime
loops=[4,2]
class ThreadFunc:
def __init__(self,func,args,name=''):
self.name = name
self.func = func
self.args = args

def __call__(self):#当Thread代码调用我们的ThreadFunc对象的时候，它将调用__call__()构造特殊方法
apply(self.func,self.args)#可以用self.res = self.func(*self.args)代替


def loop(nloop,nsec):
print 'start loop',nloop,'at:',ctime(time())
sleep(nsec)
print 'loop',nloop,'done at:',ctime(time())

def main():
print 'starting threading ... '
threads = []
nloops = range(len(loops))

for i in nloops:
t = threading.Thread(target=ThreadFunc(loop,(i,loops),loop.__name__))
threads.append(t)
　　for i in nloops:
threads.start()

　　for i in nloops:
threads.join()
print 'all done at :',ctime(time())
　　3)从Thread推导子类并创建子类实例
#!/usr/bin/env python
import threading
from time import sleep,time,ctime
loops=[4,2]
class MyThread(threading.Thread):
def __init__(self,func,args,name=''):
threading.Thread.__init__(self)
self.name = name
self.func = func
self.args = args
def run(self):
apply(self.func,self.args)#没有特殊方法__call__，现在是run()

def loop(nloop,nsec):
print 'start loop',nloop,'at:',ctime(time())
sleep(nsec)
print 'loop',nloop,'done at:',ctime(time())

def main():
print 'starting threading ... '
threads = []
nloops = range(len(loops))

for i in nloops:
t = MyThread(loop,(i,loops),loop.__name__)
threads.append(t)
　　for i in nloops:
threads.start()

　　for i in nloops:
threads.join()
print 'all done at :',ctime(time())
　　
下面给出一个制造商-消费商和Queue模块结合的例子，Queue模块提供线程间内部通信机制，它允许线程们彼此共享数据
　　#!/usr/bin/env python
import threading
from random import randint
from time import time,ctime,sleep
from Queue import Queue
　　class MyThread(threading.Thread):
def __init__(self,func,args,name=''):
threading.Thread.__init__(self)
self.name = name
self.func = func
self.args = args
def getResult(self):
return self.res

def run(self):
print '##############','starting',self.name,'at',ctime(time())
self.res=apply(self.func,self.args)
print '**************',self.name,'finished at:',ctime(time())

def writeQ(queue):
print 'producing object for Q ...',queue.put('xxx',1),
print ' size now :',queue.qsize()

def readQ(queue):
val = queue.get(1)#函数get(block=0)，从队列中取出item.如果给出了block值(0)，它就会阻塞直到队列里至少有一项数据为止
print 'consumed object from Q ... size now :',queue.qsize()
print '\n'

def writer(queue,loops):
for i in range(loops):
writeQ(queue)
sleep(randint(1,3))

def reader(queue,loops):
for i in range(loops):
readQ(queue)
sleep(randint(2,5))

funcs=[writer,reader]
nfuncs=range(len(funcs))
　　def main():
nloops=randint(5,10)
q=Queue(32)
threads=[]
print 'generating queue with initial size =',q.qsize()
for i in nfuncs:
t=MyThread(funcs,(q,nloops),funcs.__name__)
threads.append(t)

for i in nfuncs:
threads.start()

for i in nfuncs:
threads.join()

print ' ..................all Done'

if __name__ == '__main__':
main()