python-thread & thre

发布时间：2019-08-13 07:40:02编辑：auto阅读（1527）

参考：http://blog.csdn.net/eastmount/article/details/50155353

# 1、没有线程的例子
# 使用time.sleep()函数来演示线程的工作，这个例子主要为后面线程做对比。
# time.sleep()需要一个浮点型的参数，来指定“睡眠”的时间（单位秒）。这就相当于程序的运行会被挂起指定的时间。
# 代码解释：两个计时器，loop0睡眠4秒，loop1()睡眠2秒，它们是在一个进程或者线程中，顺序地执行loop0()和loop1()，那总运行时间为6秒。有可能启动过程中会再花些时间。

from time import sleep, ctime 

def loop0():  
    print 'Start loop 0 at:', ctime()  
    sleep(4)  
    print 'Loop 0 done at:', ctime() 

def loop1():  
    print 'Start loop 1 at:', ctime()  
    sleep(2)  
    print 'Loop 1 done at:', ctime() 

def main():  
    print 'Starting at:', ctime()  
    loop0()  
    loop1()  
    print 'All done at:', ctime() 

if __name__ == '__main__':  
    main()

# result：
Starting at: Wed Jul 26 23:10:41 2017
Start loop 0 at: Wed Jul 26 23:10:41 2017   # loop0() sleep(4)
Loop 0 done at: Wed Jul 26 23:10:45 2017
Start loop 1 at: Wed Jul 26 23:10:45 2017   # loop1() sleep(2)
Loop 1 done at: Wed Jul 26 23:10:47 2017
All done at: Wed Jul 26 23:10:47 2017
[Finished in 6.1s]

# 2、避免使用thread模块
#          Python提供了几个用于多线程编程的模块，包括thread、threading和Queue等。
#          (1) thread模块: 允许程序员创建和管理线程，它提供了基本的线程和锁的支持。
#          (2) threading模块: 允许程序员创建和管理线程，它提供了更高级别，更强的线程管理的功能。
#          (3) Queue模块: 允许用户创建一个可用于多个线程间共享数据的队列数据结构。
#          下面简单分析为什么需要避免使用thread模块？
#          (1) 首先更高级别的threading模块更为先进，对线程的支持更为完善，而且使用thread模块里的属性有可能会与threading出现冲突。
#          (2) 其次，低级别的thread模块的同步原语很少（实际只有一个），而threading模块则有很多。
#          (3) 另一个原因是thread对你的进程什么时候应该结束完全没有控制，当主线程结束时，所有的线程都会被强制结束掉，没有警告也不会有正常的清除工作。而threading模块能确保重要的子线程退出后进程才退出。
#          当然，为了你更好的理解线程，还是会对thread进行讲解。但是我们只建议那些有经验的专家想访问线程的底层结构时，才使用thread模块。而如果可以，你的第一个线程程序应尽可能使用threading等高级别的模块。

 

# 3、Thread模块实现多线程

# -*- coding: utf-8 -*-
import thread
from time import sleep, ctime
def loop0():
    print 'Start loop 0 at:', ctime()
    sleep(4)
    print 'Loop 0 done at:', ctime()
def loop1():
    print 'Start loop 1 at:', ctime()
    sleep(2)
    print 'Loop 1 done at:', ctime()
def main():
    try:
        print 'Starting at:', ctime()
        thread.start_new_thread(loop0, ())
        thread.start_new_thread(loop1, ())
        sleep(6)                            #同步：主线程等待子线程结束后，再结束；否则，直接关闭子线程，没有提示
        print 'All done at:', ctime()
    except Exception,e:      
        print 'Error:',e  
    finally:    
        print 'END\n' 
if __name__ == '__main__':
    main()

# result：
Starting at: Thu Jul 27 08:54:20 2017
Start loop 0 at: Thu Jul 27 08:54:20 2017
Start loop 1 at: Thu Jul 27 08:54:20 2017
Loop 1 done at: Thu Jul 27 08:54:22 2017
Loop 0 done at: Thu Jul 27 08:54:24 2017
All done at: Thu Jul 27 08:54:26 2017
END

# 4、线程加锁方法
#         那么，有什么好的管理线程的方法呢？而不是在主线程里做个额外的延时6秒操作。因为总的运行时间并不比单线程的代码少；
#         而且使用sleep()函数做线程的同步操作是不可靠的；如果循环的执行时间不能事先确定的话，这可能会造成主线程过早或过晚的退出。
#         这就需要引入锁的概念。下面代码执行loop函数，与前面代码的区别是不用为线程什么时候结束再做额外的等待了。
#         使用锁之后，可以在两个线程都退出后，马上退出。
#coding=utf-8
import thread 
from time import sleep, ctime 
 
loops = [4,2]                           #等待时间
#锁序号 等待时间 锁对象
def loop(nloop, nsec, lock):
    print 'start loop', nloop, 'at:', ctime() 
    sleep(nsec) 
    print 'loop', nloop, 'done at:', ctime()
    lock.release()                      #解锁                  
 
def main():
    print 'starting at:', ctime()
    locks =[]
    nloops = range(len(loops))          #以loops数组创建列表并赋值给nloops
         
    for i in nloops:
        lock = thread.allocate_lock()   #创建锁对象
        lock.acquire()                  #获取锁对象 加锁
        locks.append(lock)              #追加到locks[]数组中
    #执行多线程 (函数名,函数参数)
    for i in nloops:
        thread.start_new_thread(loop,(i,loops[i],locks[i]))
    #循环等待顺序检查每个所都被解锁才停止    
    for i in nloops:
        while locks[i].locked():
            pass
    print 'all end:', ctime()
if __name__ == '__main__': 
    main()

# result：
starting at: Thu Jul 27 17:05:25 2017
start loop 0 at: Thu Jul 27 17:05:25 2017
start loop 1 at: Thu Jul 27 17:05:25 2017
loop 1 done at: Thu Jul 27 17:05:27 2017
loop 0 done at: Thu Jul 27 17:05:29 2017
all end: Thu Jul 27 17:05:29 2017
[Finished in 4.5s]

# 5、创建Thread实例，传给它一个函数
#          这第一个例子使用方法一，把函数及其参数如上面Thread模块的例子一样传进去。
#          主要变化包括：添加了一些Thread对象；在实例化每个Thread对象时，把函数（target）和参数（args）都传进去，得到返回的Thread实例。
#          实例化一个Thread调用Thread()方法与调用thread.start_new_thread()之间的最大区别是：新的线程不会立即开始。
#          在你创建线程对象，但不想马上开始运行线程的时候，这是一个很有用的同步特性。
#          threading模块的Thread类有一个join()函数，允许主线程等待线程的结束。

#coding=utf-8  
import threading   
from time import sleep, ctime   
   
loops = [4,2]                      #睡眠时间  
   
def loop(nloop, nsec):  
    print 'Start loop', nloop, 'at:', ctime()   
    sleep(nsec)   
    print 'Loop', nloop, 'done at:', ctime()  
      
   
def main():  
    print 'Starting at:', ctime()  
    threads = []  
    nloops = range(len(loops))     #列表[0,1]  
          
    #创建线程  
    for i in nloops:  
        t = threading.Thread(target=loop,args=(i,loops[i]))  
        threads.append(t)  
  
    #开始线程  
    for i in nloops:  
        threads[i].start()  
  
    #等待所有结束线程  
    for i in nloops:  
        threads[i].join()  
  
    print 'All end:', ctime()   
  
if __name__ == '__main__':   
    main()

# result
Starting at: Thu Jul 27 20:44:03 2017
Start loop 0 at: Thu Jul 27 20:44:03 2017
Start loop 1 at: Thu Jul 27 20:44:03 2017
Loop 1 done at: Thu Jul 27 20:44:05 2017
Loop 0 done at: Thu Jul 27 20:44:07 2017
All end: Thu Jul 27 20:44:07 2017
[Finished in 4.2s]

# 所有的线程都创建之后，再一起调用start()函数启动线程，而不是创建一个启动一个。
# 而且，不用再管理一堆锁（分配锁、获得锁、释放锁、检查锁的状态等），只要简单地对每个线程调用join()函数就可以了。
# join()会等到线程结束，或者在给了timeout参数的时候，等到超时为止。使用join()比使用一个等待锁释放的无限循环清楚一些（也称“自旋锁”）。
# join()的另一个比较重要的方法是它可以完全不用调用。一旦线程启动后，就会一直运行，直到线程的函数结束，退出为止。
# 果你的主线程除了等线程结束外，还有其他的事情要做（如处理或等待其他的客户请求），那就不用调用join()，只有在你要等待线程结束的时候才要调用join()。

# Thread是线程类，有两种使用方法，直接传入要运行的方法或从Thread继承并覆盖run()：

# coding:utf-8
import threading
import time
#方法一：将要执行的方法作为参数传给Thread的构造方法
def action(arg):
    time.sleep(1)
    print 'the arg is:%s\r' %arg

for i in xrange(4):
    t =threading.Thread(target=action,args=(i,))
    t.start()

print 'main thread end!'

#方法二：从Thread继承，并重写run()
class MyThread(threading.Thread):
    def __init__(self,arg):
        super(MyThread, self).__init__()#注意：一定要显式的调用父类的初始化函数。
        self.arg=arg
    def run(self):#定义每个线程要运行的函数
        time.sleep(1)
        print 'the arg is:%s\r' % self.arg

for i in xrange(4):
    t =MyThread(i)
    t.start()

print 'main thread end!'

关键字：