Python多线程之threading Event

Python threading模块提供了Event对象用于线程间通信,它提供了设置、清除、等待等方法用于实现线程间的通信。event是最简单的进程间通信方式之一,一个线程产生一个信号,另一个线程则等待该信号。Python 通过threading.Event()产生一个event对象,event对象维护一个内部标志(标志初始值为False),通过set()将其置为True,wait(timeout)则用于阻塞线程直至Flag被set(或者超时,可选的),isSet()用于查询标志位是否为True,Clear()则用于清除标志位(使之为False)。

设置\清除信号

Event的set()方法可设置Event对象内部的信号标志为真,Event对象提供了isSet()方法来判断其内部信号标志的状态,使用set()方法后,isSet()方法返回True。clear()方法可清除Event对象内部的信号标志(设为False),使用clear方法后,isSet()方法返回False

等待

当Event对象的内部信号标志为False时,wait方法一直阻塞线程等待到其为真或者超时(若提供,浮点数,单位为秒)才返回,若Event对象内部标志为True则wait()方法立即返回。

举例:

下述是一段模拟“客户端监听并处理硬件端口消息”的程序片段:硬件端口消息发送时机是随机的(通过random实现),read线程负责读消息并通知parse线程去处理。

import threading
import time
import random
L = []
def read():
    count =2
    while 1:
        count = random.randint(0,1)
        if count:
            L.append('Hello, darling,I love you\n')
            L.append('You are so sweet~\n')
        if L:
           evt.set()
           print 'new rcvd sent to \'parse thread\'\n'
        time.sleep(2)
    print 'never here\n'   

def parse():
    while 1:
       if evt.isSet():
            evt.clear()
            print repr(len(L)) +' messages to parse:\n'
            while L:
                print L.pop(0)
            print 'all msg prased,sleep 2s\n'
            time.sleep(2)
       else:
            print 'no message rcved\n'
            time.sleep(2)
    print 'quit parse\n'
if __name__ == '__main__':
    evt = threading.Event()
    R = threading .Thread(target = read)
    P = threading .Thread(target = parse)
    R.start()
    P.start()
    time.sleep(2)
    R.join()
    P.join()
    #time.sleep(2)
    print 'end'  
时间: 2024-10-27 05:48:17

Python多线程之threading Event的相关文章

Python多线程之threading模块

使用threading.Thread类,有三种创建线程的方法: 创建一个Thread类,传给它一个函数: 创建一个Thread类,传给它一个可调用的类对象: 从Thread派生出一个类,创建一个这个子类的实例. # 方法1和方法2的创建方法类似 import threading def func(k):     print('thread %s replies %s'%(threading.currentThread().getName(), k**2)) if __name__ == '__m

Python 多线程之threading condition

使用Condition对象可以在某些事件触发或者达到特定的条件后才处理数据,Condition除了具有Lock对象的acquire方法和release方法外,还有wait方法.notify方法.notifyAll方法等用于条件处理. threading.Condition([lock]):创建一个condition,支持从外界引用一个Lock对象(适用于多个condtion共用一个Lock的情况),默认是创建一个新的Lock对象. acquire()/release():获得/释放 Lock w

python多线程之threading、ThreadPoolExecutor.map

背景: 某个应用场景需要从数据库中取出几十万的数据时,需要对每个数据进行相应的操作.逐个数据处理过慢,于是考虑对数据进行分段线程处理: 方法一:使用threading模块 代码: 1 # -*- coding: utf-8 -*- 2 import math 3 import random 4 import time 5 from threading import Thread 6 7 _result_list = [] 8 9 10 def split_df(): 11 # 线程列表 12 t

python 线程之 threading(三)

python 线程之 threading(一)http://www.cnblogs.com/someoneHan/p/6204640.html python 线程之 threading(二)http://www.cnblogs.com/someoneHan/p/6209240.html 使用threading.Thread.is_alive()这个方法可以判断线程是否是存活状态.但是在现有的基础上不能够直到线程什么时候开始,什么时候结束,什么时候被打断. 如果有一个或者多个线程需要在另外的一个线

python 线程之 threading(四)

python 线程之 threading(三) http://www.cnblogs.com/someoneHan/p/6213100.html中对Event做了简单的介绍. 但是如果线程打算一遍一遍的重复通知某个事件.应该使用Condition 1. 使用Condition首先应该获取Condition即使Condition进入锁的状态 2. 在线程执行过程中需要等待其他线程通知,然后才开始向下运行的地方使用Condition.wait()方法,线程进入阻塞状态. 3. 使用Condition

python多线程之Condition(条件变量)

#!/usr/bin/env python # -*- coding: utf-8 -*- from threading import Thread, Condition import time items = [] condition = Condition() class Consumer(Thread): def __init__(self): Thread.__init__(self) def consume(self): global condition global items co

Python线程之threading

线程是属于进程的,线程运行在进程空间内,同一进程所产生的线程共享同一内存空间,当进程退出时该进程所产生的线程都会被强制退出并清除.进程是资源分配的最小单位,线程是CPU调度的最小单位,每一个进程中至少有一个线程,线程可与属于同一进程的其它线程共享进程所拥有的全部资源,但是其本身基本上不拥有系统资源,只拥有一点在运行中必不可少的信息(如程序计数器.一组寄存器和栈). Threading模块提供线程相关的操作,Threading模块包含Thread,Lock,RLock,Event,Queue等组件

python 线程之threading(五)

在学习了Event和Condition两个线程同步工具之后还有一个我认为比较鸡肋的工具 semaphores 1. 使用semaphores的使用效果和Condition的notify方法的效果基本相同.每次只能通知一个阻塞线程继续运行 2. 信号量同步基于内部计数器,每调用一次acquire(),计数器减1:每调用一次release(),计数器加1.当计数器为0时,acquire()调用被阻塞 1 import threading 2 import time 3 4 def countdown

python多线程之t.setDaemon(True) 和 t.join()

0.目录 1.参考2.结论    (1)通过 t.setDaemon(True) 将子线程设置为守护进程(默认False),主线程结束后,守护子线程随之中止.    (2) t.join() 用于阻塞主线程,可以想象成将某个子线程的执行过程插入(join)到主线程的时间线上,主线程的后续代码延后执行.注意和 t.start() 分开写在两个for循环中.    (3)第一个for循环同时启动了所有子线程,随后在第二个for循环中执行t.join() ,主线程实际被阻塞的总时长==其中执行时间最长