zoukankan      html  css  js  c++  java
  • python多线程(一)

    原文:http://www.pythonclub.org/python-basic/threading

    一、python多线程thread和threading实现

    python是支持多线程的,并且是native的线程。主要是通过thread和threading这两个模块来实现的。

    python的thread模块是比较底层的模块,python的threading模块是对thread做了一些包装的,可以更加方便的被使用。

    这里需要提一下的是python对线程的支持还不够完善,不能利用多CPU,但是下个版本的python中已经考虑改进这点,让我们拭目以待吧。

    threading模块里面主要是对一些线程的操作对象化了,创建了叫Thread的class。

    一般来说,使用线程有两种模式,一种是创建线程要执行的函数,把这个函数传递进Thread对象里,让它来执行;另一种是直接从Thread继承,创建一个新的class,把线程执行的代码放到这个新的 class里。

    我们来看看这两种做法吧。

    http://blog.csdn.net/guopengzhang/article/details/5458091

    一)线程基础

    1、创建线程:

    thread模块提供了start_new_thread函数,用以创建线程。start_new_thread函数成功创建后还可以对其进行操作。

    其函数原型:

        start_new_thread(function,atgs[,kwargs])

    其参数含义如下:

        function: 在线程中执行的函数名

        args:元组形式的参数列表。

        kwargs: 可选参数,以字典的形式指定参数

    方法一:通过使用thread模块中的函数创建新线程。

    >>> import thread
    >>> def run(n):
        for i in range(n):
            print i
    
            
    >>> thread.start_new_thread(run,(4,))   #注意第二个参数一定要是元组的形式
    53840
    
    
    1
    >>> 
    2
    3
    KeyboardInterrupt
    >>> thread.start_new_thread(run,(2,))
    17840
    
    
    1
    >>> 
    thread.start_new_thread(run,(),{'n':4})
    39720
    
    
    1
    >>> 
    2
    3
    thread.start_new_thread(run,(),{'n':3})
    32480
    
    
    1
    >>> 
    2

     方法二:通过继承threading.Thread创建线程

    >>> import threading
    >>> class mythread(threading.Thread):
        def __init__(self,num):
            threading.Thread.__init__(self)
            self.num = num
        def run(self):               #重载run方法
            print 'I am', self.num
    
            
    >>> t1 = mythread(1)
    >>> t2 = mythread(2)
    >>> t3 = mythread(3)
    >>> t1.start()           #运行线程t1
    I am
    >>>  1
    t2.start()
    I am
    >>>  2
    t3.start()
    I am
    >>>  3

    方法三:使用threading.Thread直接在线程中运行函数。

    import threading
    >>> def run(x,y):
        for i in range(x,y):
            print i
    
    >>> t1 = threading.Thread(target=run,args=(15,20)) #直接使用Thread附加函数args为函数参数
    
    >>> t1.start()
    15
    >>> 
    16
    17
    18
    19

    二)Thread对象中的常用方法:

    1、isAlive方法:

    >>> import threading
    >>> import time
    >>> class mythread(threading.Thread):
        def __init__(self,id):
            threading.Thread.__init__(self)
            self.id = id
        def run(self):
            time.sleep(5)    #休眠5秒
            print self.id
    
            
    >>> t = mythread(1)
    >>> def func():
        t.start()
        print t.isAlive()    #打印线程状态
    
        
    >>> func()
    True
    >>> 1

    2、join方法:

    原型:join([timeout]) 

        timeout: 可选参数,线程运行的最长时间

    import threading
    >>> import time     #导入time模块
    >>> class Mythread(threading.Thread):
        def __init__(self,id):
            threading.Thread.__init__(self)
            self.id = id
        def run(self):
            x = 0
            time.sleep(20)
            print self.id
    
            
    >>> def func():
        t.start()
        for i in range(5):
            print i
    
            
    >>> t = Mythread(2)
    >>> func()
    0
    1
    2
    3
    4
    >>> 2
    def func():
        t.start()
        t.join()
        for i in range(5):
            print i
    
            
    >>> t = Mythread(3)
    >>> func()
    3
    0
    1
    2
    3
    4
    >>> 

    3、线程名:

    >>> import threading
    >>> class mythread(threading.Thread):
        def __init__(self,threadname):
            threading.Thread.__init__(self,name=threadname)
        def run(self):
            print self.getName()
    
            
    >>> 
    >>> t1 = mythread('t1')
    >>> t1.start()
    t1
    >>> 

     4、setDaemon方法

    在脚本运行的过程中有一个主线程,如果主线程又创建了一个子线程,那么当主线程退出时,会检验子线程是否完成。如果子线程未完成,则主线程会在等待子线程完成后退出。

    当需要主线程退出时,不管子线程是否完成都随主线程退出,则可以使用Thread对象的setDaemon方法来设置。

    三)线程同步

    1.简单的线程同步

    使用Thread对象的Lock和RLock可以实现简单的线程同步。对于如果需要每次只有一个线程操作的数据,可以将操作过程放在acquire方法和release方法之间。如:

    # -*- coding:utf-8 -*-
    import threading
    import time
    class mythread(threading.Thread):
        def __init__(self,threadname):
            threading.Thread.__init__(self,name = threadname)
        def run(self):
            global x                #设置全局变量
    #        lock.acquire()          #调用lock的acquire方法
            for i in range(3):
                x = x + 1
            time.sleep(2)
            print x
    #        lock.release()          #调用lock的release方法
    #lock = threading.RLock()        #生成Rlock对象
    t1 = []
    for i in range(10):
        t = mythread(str(i))
        t1.append(t)
    x = 0                   #将全局变量的值设为0
    for i in t1: 
        i.start()
    
    E:/study/python/workspace>xianchengtongbu.py
    3
    6
    9
    12
    15
    18
    21
    24
    27
    30

    如果将lock.acquire()和lock.release(),lock = threading.Lock()删除后保存运行脚本,结果将是输出10个30。30是x的最终值,由于x是全局变量,每个线程对其操作后进入休眠状态,在线程休眠的时候,python解释器就执行了其他的线程而是x的值增加。当所有线程休眠结束后,x的值已被所有线修改为了30,因此输出全部为30。

    2、使用条件变量保持线程同步。

    Python的Condition对象提供了对复制线程同步的支持。使用Condition对象可以在某些事件触发后才处理数据。Condition对象除了具有acquire方法和release的方法外,还有wait方法、notify方法、notifyAll方法等用于条件处理。

    # -*- coding:utf-8 -*-
    import threading
    class Producer(threading.Thread):
        def __init__(self,threadname):
            threading.Thread.__init__(self,name = threadname)
        def run(self):
            global x
            con.acquire()
            if x == 1000000:
                con.wait()
            #    pass
            else:
                for i in range(1000000):
                    x = x + 1
                con.notify()
            print x
            con.release()
    class Consumer(threading.Thread):
        def __init__(self,threadname):
            threading.Thread.__init__(self,name = threadname)
        def run(self):
            global x 
            con.acquire()
            if x == 0:
                con.wait()
                #pass
            else:
                for i in range(1000000):
                    x = x - 1
                con.notify()
            print x 
            con.release()
    con = threading.Condition()
    x = 0
    p = Producer('Producer')
    c = Consumer('Consumer')
    p.start()
    c.start()
    p.join()
    c.join()
    print x
    
    E:/study/python/workspace>xianchengtongbu2.py
    1000000
    0
    0

    线程间通信:

    Event对象用于线程间的相互通信。他提供了设置信号、清除信宏、等待等用于实现线程间的通信。

    1、设置信号。Event对象使用了set()方法后,isSet()方法返回真。

    2、清除信号。使用Event对象的clear()方法后,isSet()方法返回为假。

    3、等待。当Event对象的内部信号标志为假时,则wait()方法一直等到其为真时才返回。还可以向wait传递参数,设定最长的等待时间。

    # -*- coding:utf-8 -*-
    import threading
    class mythread(threading.Thread):
        def __init__(self,threadname):
            threading.Thread.__init__(self,name = threadname)
        def run(self):
            global event
            if event.isSet():
                event.clear()
                event.wait()   #当event被标记时才返回
                print self.getName()
            else:
                print self.getName()
                event.set()
    event = threading.Event()
    event.set()
    t1 = []
    for i in range(10):
        t = mythread(str(i))
        t1.append(t)
    for i in t1:
        i.start()
  • 相关阅读:
    Web Essentials之样式表StyleSheets
    Web Essentials之Bundling
    Web Essentials之Browser Link
    Web Essentials之通用功能
    让人一用钟情的VS插件系列之一——Web Essentials(Web开发必备利器)
    一用钟情的VS插件系列总目录(值得收藏)
    win7升级为Win10 10586版本,出现应用商店打不开的解决办法
    麻将游戏
    最少转弯问题
    统计学生信息(使用链表完成)
  • 原文地址:https://www.cnblogs.com/cj2014/p/3835373.html
Copyright © 2011-2022 走看看