Python学习心得(七) 深入理解threading多线程模块

import thread 
from time import sleep,ctime,strftime

loops = [4,2]

def loop(nloop,nsec,lock):
    print ‘start loop‘,nloop,‘at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘) 
    sleep(nsec)
    print ‘loop‘,nloop,‘done,at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    lock.release() #释放锁
def main():
    print ‘starting at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    locks = []
    nloops = range(len(loops)) #[0, 1]
    for i in nloops:
        lock = thread.allocate_lock() #获取LockType锁对象
        lock.acquire() #取得每个锁(相当于"把锁锁上")
        locks.append(lock) #一旦锁被锁上，就可以把它添加到锁列表locks中了
        #print locks
    for i in nloops: #派生线程
        #每个线程会调用loop()函数，并传递循环号、睡眠时间以及用于该线程的锁
        thread.start_new_thread(loop,(i,loops[i],locks[i]))
        sleep(1)
    for i in nloops:
        while locks[i].locked(): #暂停主线程，等待，直到所有锁都被释放之后才会继续执行
            pass
    print ‘all done at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    
if __name__ == ‘__main__‘:
    main()

import threading
#threading模块的Thread类有一个join()方法，可以让主线程等待所有线程执行完毕

from time import sleep,strftime

loops = [4,2,2]

def loop(nloop,nsec):
    print ‘start loop‘,nloop,‘at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘) 
    sleep(nsec)
    print ‘loop‘,nloop,‘done,at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
def main():
    print ‘starting at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    threads = []
    nloops = range(len(loops)) #[0, 1]
    
    for i in nloops:
        #实例化Thread（调用Thread()和之前调用thread.start_new_thread()最大区别在于新线程不会立即开始执行
        t = threading.Thread(target=loop,args=(i,loops[i])) #这是个非常有用的同步功能
        threads.append(t)

    for i in nloops: #启动线程
        #当所有线程都分配完成后，通过调用每个线程的start()方法来让它们执行，而不是在这之前就会执行
        threads[i].start()
        
    for i in nloops: 
        #为每个线程调用join()方法，join()方法将等待线程结束，或在提供了超时时间的情况下，达到超时时间。
        threads[i].join() 
        #join()方法只有在你需要等待线程完成的时候才有用
        #join()方法其实根本不需要调用，一旦线程启动，它们就会一直执行，直到给定的函数完成后退出。
        
    print ‘all done at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)

print loop.__name__
    
if __name__ == ‘__main__‘:
    main()

import threading
from time import sleep,strftime

loops = [4,2]

class ThreadFunc(object): #添加ThreadFunc类
    def __init__(self,func,args,name = ‘‘): #构造方法设定函数自身，函数参数及函数名的字符串
        self.name = name
        self.func = func
        self.args = args
    def __call__(self): #__call__特殊方法直接调用
        self.func(*self.args)

def loop(nloop,nsec):
    print ‘start loop‘,nloop,‘at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    sleep(nsec)
    print ‘loop‘,nloop,‘done at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)

def main():
    print ‘starting at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    threads = []
    nloops = range(len(loops))
    
    for i in nloops: #实例化Thread类对象
        t = threading.Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__)) #分配线程
        threads.append(t) 
    
    for i in nloops:
        threads[i].start() #真正通过start()方法才启动线程
                           
    
    for i in nloops:
        threads[i].join() #等待线程完成
    print ‘all done at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)   
    
if __name__ == ‘__main__‘:
    main()        

‘‘‘
import threading
from time import sleep,strftime

loops = [4,2]

class MyThread(threading.Thread):
    def __init__(self,func,args,name=‘‘):
        threading.Thread.__init__(self) #MyThread子类的构造方法必须先调用基类(即父类)的构造方法
        self.name = name
        self.func = func        
        self.args = args
   
    def run(self): #之前的特殊方法__call__在这里必须要写成run()
        self.func(*self.args)
 
def loop(nloop,nsec):
    print ‘start loop‘,nloop,‘at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    sleep(nsec)
    print ‘loop‘,nloop,‘done at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)

def main():
    print ‘starting at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    threads = []
    nloops = range(len(loops)) 
    #print nloops
    
    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:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
    
if __name__ == ‘__main__‘:
    main()
                   
‘‘‘

#Thread子类MyThread 
#将上面的代码独立作为一个模块，把结果保存在实例属性self.res中，并创建一个新的方法getResult()来获取这个值

import threading
from time import strftime

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:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)
        self.res = self.func(*self.args)
        print self.name,‘finished at:‘,strftime(‘%Y-%m-%d %H:%M:%S‘)