线程和python

用锁进行线程的同步例子

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[i],locks[i]))
        #创建线程运行，语法和apply内建函数是完全一样的，loop函数，函数参数(i,loops[i],locks[i])
       
    for i in nloops:
        while locks[i].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[i]))
        threads.append(t)

    for i in nloops:#调用每个线程的start()方法让他们一起冲出起跑线
        threads[i].start()
       

    for i in nloops:
        threads[i].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[i]),loop.__name__))
        threads.append(t)

    for i in nloops:
        threads[i].start()
       

    for i in nloops:
        threads[i].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[i]),loop.__name__)
        threads.append(t)

    for i in nloops:
        threads[i].start()
       

    for i in nloops:
        threads[i].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[i],(q,nloops),funcs[i].__name__)
        threads.append(t)
       
    for i in nfuncs:
        threads[i].start()
       
    for i in nfuncs:
        threads[i].join()
       
    print ' ..................all Done'
   
if __name__ == '__main__':
    main()