专栏首页python3python-thread & thre

python-thread & thre

参考: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!'

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • python线程、协程

    如果同一时间有多个线程操作同一数据可能会出现混乱现象,所以需要加线程锁保证同一时间只有一个线程操作这一数据,保证数据一致性

    用户2398817
  • python多线程开发

           通过threading.Thread创建一个线程对象,target是目标函数,name可以指定自己喜欢的名字,线程的启动需要借助start方法。线...

    用户2398817
  • Python学习记录-多进程和多线程

    狭义定义:进程是正在运行的程序的实例(an instance of a computer program that is being executed)。 广义...

    用户2398817
  • 【爬虫】(二)爬取西电教务处成绩

    一点儿也不潇洒
  • Python学习记录-多进程和多线程

    狭义定义:进程是正在运行的程序的实例(an instance of a computer program that is being executed)。 广义...

    用户2398817
  • 美联通证:区块链+美业的未来

    相信大家都使用过淘宝、京东吧,淘宝、京东作为第三方中介,是整个交易的唯一裁判,记录整个交易。买家在没收到货的情况下把钱交给淘宝、京东保管,而卖家也在没收到钱的情...

    用户3701487
  • 有效感受野

    Understanding the Effective Receptive Field in Deep Convolutional Neural Network...

    用户1148525
  • 微信小程序版博客——小程序授权登陆的一点优化

    通常授权登陆在第一次登陆小程序时提示,但很多用户会拒绝,接下来的流程就比较尴尬了。

    Bug生活2048
  • 如何在spark里面使用窗口函数

    在大数据分析中,窗口函数最常见的应用场景就是对数据进行分组后,求组内数据topN的需求,如果没有窗口函数,实现这样一个需求还是比较复杂的,不过现在大多数标准SQ...

    我是攻城师
  • 机器学习思维导图

    机械视角

扫码关注云+社区

领取腾讯云代金券

玩转腾讯云 有奖征文活动