Python线程指南

最新推荐文章于 2024-05-08 08:08:08 发布
最新推荐文章于 2024-05-08 08:08:08 发布
阅读量2.9k 收藏 3
点赞数
分类专栏： python

http://www.cnblogs.com/huxi/archive/2010/06/26/1765808.html


3. threading

threading基于Java的线程模型设计。锁（Lock）和条件变量（Condition）在Java中是对象的基本行为（每一个对象都自带了锁和条件变量），而在Python中则是独立的对象。Python Thread提供了Java Thread的行为的子集；没有优先级、线程组，线程也不能被停止、暂停、恢复、中断。Java Thread中的部分被Python实现了的静态方法在threading中以模块方法的形式提供。

threading 模块提供的常用方法： 
threading.currentThread(): 返回当前的线程变量。 
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

threading模块提供的类：  
Thread, Lock, Rlock, Condition, [Bounded]Semaphore, Event, Timer, local.

3.1. Thread

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


# encoding: UTF-8
import threading
 
# 方法1：将要执行的方法作为参数传给Thread的构造方法
def func():
    print 'func() passed to Thread'
 
t = threading.Thread(target=func)
t.start()
 
# 方法2：从Thread继承，并重写run()
class MyThread(threading.Thread):
    def run(self):
        print 'MyThread extended from Thread'
 
t = MyThread()
t.start()

构造方法： 
Thread(group=None, target=None, name=None, args=(), kwargs={}) 
group: 线程组，目前还没有实现，库引用中提示必须是None； 
target: 要执行的方法； 
name: 线程名； 
args/kwargs: 要传入方法的参数。

实例方法： 
isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。 
get/setName(name): 获取/设置线程名。 
is/setDaemon(bool): 获取/设置是否守护线程。初始值从创建该线程的线程继承。当没有非守护线程仍在运行时，程序将终止。 
start(): 启动线程。 
join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。

一个使用join()的例子：


# encoding: UTF-8
import threading
import time
 
def context(tJoin):
    print 'in threadContext.'
    tJoin.start()
    
    # 将阻塞tContext直到threadJoin终止。
    tJoin.join()
    
    # tJoin终止后继续执行。
    print 'out threadContext.'
 
def join():
    print 'in threadJoin.'
    time.sleep(1)
    print 'out threadJoin.'
 
tJoin = threading.Thread(target=join)
tContext = threading.Thread(target=context, args=(tJoin,))
 
tContext.start()

in threadContext. 
in threadJoin. 
out threadJoin. 
out threadContext.


3.2. Lock

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

构造方法： 
Lock()

实例方法： 
acquire([timeout]): 使线程进入同步阻塞状态，尝试获得锁定。 
release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。


# encoding: UTF-8
import threading
import time
 
data = 0
lock = threading.Lock()
 
def func():
    global data
    print '%s acquire lock...' % threading.currentThread().getName()
    
    # 调用acquire([timeout])时，线程将一直阻塞，
    # 直到获得锁定或者直到timeout秒后（timeout参数可选）。
    # 返回是否获得锁。
    if lock.acquire():
        print '%s get the lock.' % threading.currentThread().getName()
        data += 1
        time.sleep(2)
        print '%s release lock...' % threading.currentThread().getName()
        
        # 调用release()将释放锁。
        lock.release()
 
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t3 = threading.Thread(target=func)
t1.start()
t2.start()
t3.start()

3.3. RLock

RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。

可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。

构造方法： 
RLock()

实例方法： 
acquire([timeout])/release(): 跟Lock差不多。


# encoding: UTF-8
import threading
import time
 
rlock = threading.RLock()
 
def func():
    # 第一次请求锁定
    print '%s acquire lock...' % threading.currentThread().getName()
    if rlock.acquire():
        print '%s get the lock.' % threading.currentThread().getName()
        time.sleep(2)
        
        # 第二次请求锁定
        print '%s acquire lock again...' % threading.currentThread().getName()
        if rlock.acquire():
            print '%s get the lock.' % threading.currentThread().getName()
            time.sleep(2)
        
        # 第一次释放锁
        print '%s release lock...' % threading.currentThread().getName()
        rlock.release()
        time.sleep(2)
        
        # 第二次释放锁
        print '%s release lock...' % threading.currentThread().getName()
        rlock.release()
 
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t3 = threading.Thread(target=func)
t1.start()
t2.start()
t3.start()

3.4. Condition

Condition（条件变量）通常与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将自己生成一个RLock实例。

可以认为，除了Lock带有的锁定池外，Condition还包含一个等待池，池中的线程处于状态图中的等待阻塞状态，直到另一个线程调用notify()/notifyAll()通知；得到通知后线程进入锁定池等待锁定。

构造方法： 
Condition([lock/rlock])

实例方法： 
acquire([timeout])/release(): 调用关联的锁的相应方法。 
wait([timeout]): 调用这个方法将使线程进入Condition的等待池等待通知，并释放锁。使用前线程必须已获得锁定，否则将抛出异常。 
notify(): 调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定（进入锁定池）；其他线程仍然在等待池中。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。 
notifyAll(): 调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。

例子是很常见的生产者/消费者模式：


# encoding: UTF-8
import threading
import time
 
# 商品
product = None
# 条件变量
con = threading.Condition()
 
# 生产者方法
def produce():
    global product
    
    if con.acquire():
        while True:
            if product is None:
                print 'produce...'
                product = 'anything'
                
                # 通知消费者，商品已经生产
                con.notify()
            
            # 等待通知
            con.wait()
            time.sleep(2)
 
# 消费者方法
def consume():
    global product
    
    if con.acquire():
        while True:
            if product is not None:
                print 'consume...'
                product = None
                
                # 通知生产者，商品已经没了
                con.notify()
            
            # 等待通知
            con.wait()
            time.sleep(2)
 
t1 = threading.Thread(target=produce)
t2 = threading.Thread(target=consume)
t2.start()
t1.start()

上面的例子对condition的解释说明有不详细的地方，以下是我的理解

1. 条件变量通常是和互斥量配合使用，threading.Condition([lock])，可以在构造条件变量的时候不指定互斥量，会自动创建一个互斥锁；当几个条件变量共享一个互斥锁时，就要传递这个互斥锁

2. 看一个官网给出的例子

# Consume one item
cv.acquire()
while not an_item_is_available():
    cv.wait()
get_an_available_item()
cv.release()

# Produce one item
cv.acquire()
make_an_item_available()
cv.notify()
cv.release()

在实际编写程序时，往往在这两段代码前包上while True

这段代码问题在于，生产者会不停的生产，有写产品，消费者来不及消费，就被新产品覆盖

wait的内部实现是：

 1. 释放锁

 2. 堵塞线程，直到收到notify或者notifiall的信号

 3. 加锁

所以，在wait之前此线程一定要得到锁了，否则会有异常


3. notify或者notifyall在调用之前也一定要加锁，否则有异常

notify会从所有等待线程中选择一个唤醒

notifyall会唤醒所有等待线程，但是这些线程要竞争得到一个锁，因为wait的第3步是一个加锁的步骤


上面的代码比较trick的应用了wait这一个特性，

生产者在生成一个产品后，wait,就释放了锁，消费者得到锁之后，解除wait, 消费一个产品，再次进入wait, 释放锁，此时生产者也解除了wait


我的代码如下：

count = 0

def producer():
	global product, count
	while True:
		con.acquire()
		while product is not None:
			con.wait()
		count += 1
		product = count
		print 'producing %d' %product
		con.notify()
		time.sleep(2)
		con.release()

def consumer():
	global product, count
	while True:
		con.acquire()
		while product is None:
			con.wait()
		print 'consuming %d' %count
		time.sleep(2)
		product = None
		con.notify()
		con.release()

用条件变量实现生产者/消费者在逻辑上不够简洁，用semaphore比较清楚，请见

http://blog.csdn.net/sunmenggmail/article/details/7679152


3.5. Semaphore/BoundedSemaphore

Semaphore（信号量）是计算机科学史上最古老的同步指令之一。Semaphore管理一个内置的计数器，每当调用acquire()时-1，调用release() 时+1。计数器不能小于0；当计数器为0时，acquire()将阻塞线程至同步锁定状态，直到其他线程调用release()。

基于这个特点，Semaphore经常用来同步一些有“访客上限”的对象，比如连接池。

BoundedSemaphore 与Semaphore的唯一区别在于前者将在调用release()时检查计数器的值是否超过了计数器的初始值，如果超过了将抛出一个异常。

构造方法： 
Semaphore(value=1): value是计数器的初始值。

实例方法： 
acquire([timeout]): 请求Semaphore。如果计数器为0，将阻塞线程至同步阻塞状态；否则将计数器-1并立即返回。 
release(): 释放Semaphore，将计数器+1，如果使用BoundedSemaphore，还将进行释放次数检查。release()方法不检查线程是否已获得 Semaphore。


# encoding: UTF-8
import threading
import time
 
# 计数器初值为2
semaphore = threading.Semaphore(2)
 
def func():
    
    # 请求Semaphore，成功后计数器-1；计数器为0时阻塞
    print '%s acquire semaphore...' % threading.currentThread().getName()
    if semaphore.acquire():
        
        print '%s get semaphore' % threading.currentThread().getName()
        time.sleep(4)
        
        # 释放Semaphore，计数器+1
        print '%s release semaphore' % threading.currentThread().getName()
        semaphore.release()
 
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t3 = threading.Thread(target=func)
t4 = threading.Thread(target=func)
t1.start()
t2.start()
t3.start()
t4.start()
 
time.sleep(2)
 
# 没有获得semaphore的主线程也可以调用release
# 若使用BoundedSemaphore，t4释放semaphore时将抛出异常
print 'MainThread release semaphore without acquire'
semaphore.release()


3.6. Event

Event（事件）是最简单的线程通信机制之一：一个线程通知事件，其他线程等待事件。Event内置了一个初始为False的标志，当调用set()时设为True，调用clear()时重置为 False。wait()将阻塞线程至等待阻塞状态。

Event其实就是一个简化版的 Condition。Event没有锁，无法使线程进入同步阻塞状态。

构造方法： 
Event()

实例方法： 
isSet(): 当内置标志为True时返回True。 
set(): 将标志设为True，并通知所有处于等待阻塞状态的线程恢复运行状态。 
clear(): 将标志设为False。 
wait([timeout]): 如果标志为True将立即返回，否则阻塞线程至等待阻塞状态，等待其他线程调用set()。



# encoding: UTF-8
import threading
import time
 
event = threading.Event()
 
def func():
    # 等待事件，进入等待阻塞状态
    print '%s wait for event...' % threading.currentThread().getName()
    event.wait()
    
    # 收到事件后进入运行状态
    print '%s recv event.' % threading.currentThread().getName()
 
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t1.start()
t2.start()
 
time.sleep(2)
 
# 发送事件通知
print 'MainThread set event.'
event.set()

注意set，会将event设为True，然后所有wait的线程都会被唤醒

上面的代码输出是：

Thread-2 waiting for event...
Thread-1 waiting for event...
mainthread set event
Thread-1 recv event
Thread-2 recv event

而不是只有一个线程被唤醒


3.7. Timer

Timer（定时器）是Thread的派生类，用于在指定时间后调用一个方法。

构造方法： 
Timer(interval, function, args=[], kwargs={}) 
interval: 指定的时间 
function: 要执行的方法 
args/kwargs: 方法的参数

实例方法： 
Timer从Thread派生，没有增加实例方法。

# encoding: UTF-8
import threading
 
def func():
    print 'hello timer!'
 
timer = threading.Timer(5, func)
timer.start()

3.8. local

local是一个小写字母开头的类，用于管理 thread-local（线程局部的）数据。对于同一个local，线程无法访问其他线程设置的属性；线程设置的属性不会被其他线程设置的同名属性替换。

可以把local看成是一个“线程-属性字典”的字典，local封装了从自身使用线程作为 key检索对应的属性字典、再使用属性名作为key检索属性值的细节。


local = threading.local()


local.ttname = 'main'
def func():
	local.ttname = '%s ' %threading.currentThread().getName()
	print local.ttname
	




t1 = threading.Thread(target = func)
t2 = threading.Thread(target = func)


t1.start()
t2.start()	


print local.ttname


输出：

Thread-1 
Thread-2 
 main


注意local的特殊性，对于同一个local，线程改变的属性只是自己线程内local的属性，而其他线程不收到这个线程的影响

如果local只是一个普通类的一个实例，那么所有线程共享local的属性







sunmenggmail
关注
专栏目录
python线程唤醒_python 多线程
weixin_32540969的博客
02-21 1206
python 多线程真正的多线程吗？对于多核处理器，在同一时间确实可以多个线程独立运行，但在Python中确不是这样的了。原因在于，python虚拟机中引入了GIL这一概念。GIL(Global Interpreter Lock)全局解析器锁是用来解决共享资源访问的互斥问题，导致在python虚拟机中同一时间只能有一个线程访问python所提供的API。那么python是如何支持多线程的呢？在操作...
Java多线程随笔（2）：线程状态
AVOP_210的博客
09-27 578
探究Thread类 1. lambda 表达式 优势： 避免匿名内部类定义过多 可以让代码更简洁 去掉没有意义的代码，只留下核心逻辑 函数式接口：任何接口，如果只包含一个抽象方法，那么他就是一个函数式接口。 对于函数式接口，我们可以通过lambda表达式来创建接口的对象。 Runnable接口只有符合函数式接口，因此可以在实现Runnable接口时直接使用Lambda表达式。 各种接口实现举例： public class Lambda { //3.静态内部类 ...
并发编程基础 - synchronized和volatile并发模型对比、从顶层俯瞰juc
it_lihongmin的博客
10-25 476
目录 一、juc包存的意义【解决了synchronized没有解决的部分问题】 1、能够响应中断2、支持超时3、非阻塞地获取锁 二、juc包个人理解分为三个部分 1、atomic工具包 2、AQS 3、线程池 三、LockSupport和Unsafe类 四、CAS存在的问题和解决方案 1、ABA问题 2、单个对象问题 synchronized关键字不仅要解决原则性可见性和有序性问题，还需要Object（ObjectMonitor）相关方法等周边配置一起才能解决所有的并发问题，虽..
Python 多线程唤醒，生产者-消费者
TuringEvo专栏
02-24 258
场景：生产者一次性生产total个商品(生产过程中不可购买),之后通知消费者抢购，当商品卖完后，由消费者通知生产者开始生产。在循环中添加一套"获取锁-释放锁",一个消费者购买完成后释放锁，其他消费者就可以获取锁来参与购买。由于场景是多个消费者进行抢购，如果将获取锁操作放在循环外(如生产者),那么一个消费者线程被唤醒时会锁住整个循环，无法实现另一个消费者的抢购。
python线程唤醒_如果发生事件，在Python中唤醒一个线程
weixin_39629467的博客
02-21 461
我知道已经有人问过这样的问题，所以从某种意义上说，这是一个重复。然而，我看了很多这样的问题，和无数的网站，我仍然不知道如何做这个问题的标题说什么。这就是我想要实现的，更具体地说：一个线程t_sensors从传感器中读取值，然后进入睡眠状态refresh_rate秒。这可能需要几个小时，因此在这段时间内，它可以再次收到从传感器读取值的请求。这个请求来自线程t_checker，它检查Firebase数...
Python 为线程命名
m0_64372444的博客
11-24 3410
本文介绍 Python 中如何为线程命名
Python Thread精准唤醒
人工智能
02-25 306
Python Thread使用Condition来实现精准唤醒（Accurate awakening）： 前提是必须Condition结合Lock来实现： 具体代码如下：
python 唤醒进程_python之路----进程（一）
weixin_39634900的博客
03-01 294
一、理论知识1、操作系统发展简介1.没有操作系统 —— 穿孔卡片2.批处理系统 —— 串行 ，速度块联机批处理 读磁带的时候速度快脱机批处理 读磁带和cpu工作并发3.多道程序系统 —— 并行操作系统的各种管理功能时空的复用 ： 空间隔离开来，cpu看起来可以处理多个任务4.分时系统 —— 更好的实现了 并行让cpu的工作效率下降了5.实时系统 —— 对一个任务实时响应优点 快缺点 能处理的任务...
在Python中获取当前线程的名字
最新发布
weixin_41489908的博客
05-08 519
多线程编程是一种常见的编程范式，它允许程序同时执行多个任务。在Python中，​​模块提供了对多线程编程的支持。了解和管理当前运行的线程是多线程编程中的一个重要方面。本技术博客将介绍如何在Python中获取当前线程的名字，并提供一系列的示例代码，以帮助您更好地理解和利用这一功能。
Python Threading线程
一碗烈酒的博客
09-01 566
目录 线程对象threading.Thread 定时器 threading.Timer 线程锁 threading.Lock 线程锁使用with 信号量 threading.BoundedSemaphore python的多线程 对 IO密集型（文件处理，爬虫）代码还是友好的，对CPU密集型（数据处理，循环等）代码不太友好 线程对象threading.Thread threading.Thread(group=None,target=None,name=None,args...
python 获取当前运行线程名称和数量 threading.enumerate()
集电极
07-21 8506
python获取当前运行线程名称和数量threading.enumerate()
多线程唤醒指定线程
snailisBigbull的博客
10-02 358
//多线程唤醒指定线程 package com.monkey1024.communication; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; /** * 使用ReenTrantLock唤醒指定线程 * */ public class Loc...
python中多线程开启的两种方式（内含有event的应用，即安全的机制，类似于java的等待唤醒机制，不会出现多个线程之间的错乱问题）
逆水行舟，不进则退
09-16 382
 event是类似于java中的等待唤醒机制，具体方法参照上一篇CSDN https://blog.csdn.net/qq_41901915/article/details/82703429 下面来介绍开启线程的第一种方式 #Filename:threading1.py #开启线程的第一种方式 import threading import time event=threading.Eve...
python中多线程中event的使用-----------------即一个灵活的方法标志位,类似于java的等待唤醒机制（python与java不同的地方）
逆水行舟，不进则退
09-14 1200
event是python中一个特有的标志位方法，他一共有三种方法 1.event.wait()：如果标志位设定了，它不做任何事，如果没有设定，则将会锁住，等待标志位的设定 2.event.set()：设置标志位 3.event.clear()：清除标志位 这一种机制很类似于java中的等待唤醒机制，我们可以试想一下，我们在一个线程中，不断的设置和清除标志位，在另一个线程中用wait()方法...
python threading.current_thread().name和.getName()有什么区别
weixin_30412167的博客
02-28 2519
今天学到python多线程这块,想显示当前线程是主线程还是子线程.网上一搜,有个方法叫 1 threading.current().name 定海偶然 但是发现,同样的threading.current_thread()后面不仅仅有.name属性,而且还有.getName()方法.但是 这2个写法最后得出的结果却是一样的. 那么,2者区别在哪里呢? 1 ...
python threading用法_python中threading超线程用法实例分析
weixin_34565946的博客
01-28 209
本文实例讲述了python中threading超线程用法。分享给大家供大家参考。具体分析如下：threading基于Java的线程模型设计。锁(Lock)和条件变量(Condition)在Java中是对象的基本行为(每一个对象都自带了锁和条件变量)，而在Python中则是独立的对象。Python Thread提供了Java Thread的行为的子集；没有优先级、线程组，线程也不能被停止、暂停、恢复...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值