python3 的并行执行的解释及例子

最新推荐文章于 2025-04-21 10:18:51 发布

红鲤鱼与绿鲤鱼与驴__

最新推荐文章于 2025-04-21 10:18:51 发布

阅读量1.9k

点赞数

分类专栏： Python 文章标签： python 并行编程 thread lock Rlock

本文链接：https://blog.youkuaiyun.com/zy13270867781/article/details/82021856

版权

Python 专栏收录该内容

19 篇文章

订阅专栏

本文深入探讨Python3的并行执行机制，通过官方文档解析threading库中的thread和锁（Lock、Rlock）概念，并提供实例演示如何在Python中实现并行操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

官方文档：https://docs.python.org/3.7/library/threading.html

class threading.Thread(group=None, target=None, name=None,args=(), kwargs=None, *, daemon=None)
target= 线程调用的函数
name = 线程名字 默认 thread_N
args = () 函数参数tulpl

.start() # 线程启动
.run() # 线程任务运行
.join(timeout=None) # 线程阻塞函数，等待线程完成 
.is_alive() # 线程join后总返回None 需要用is_alive监测线程是否运行
.setName()
.getName()

# 当前活动线程的个数
print(threading.active_count()) 
# 返回当前线程对象
print(threading.current_thread())
# 线程名和id
print(threading.current_thread().name)
print(threading.current_thread().ident)
# 返回线程标识符
print(threading.get_ident())
# 返回 活动的线程list
print(threading.enumerate())
# 返回主线程对象
print(threading.main_thread())

# 线程同步 原语锁对象
class threading.Lock()
.acquire() # 获取锁 默认阻塞
.release() # 释放锁

# 可重入锁
class threading.RLock() # 函数可以递归，并自动加锁
.acquire()
.release()

# 条件变量 : 允许一个或多个线程等待，直到另一个线程通知它们。
class threading.Condition(lock=None) #条件变量总是与某种类型的锁相关联
#可以传入一个lock或rlock作为作底层锁。否则，将创建一个新的Rlock对象，并将其用作底层锁。
.acquire()
.release()
# 此方法释放底层锁，然后阻塞，直到通过通 notify() or notify_all()
# 调用在另一个线程中调用相同的条件变量，或直到发生可选超时为止。一旦被唤醒或超时，它就会重新获得锁并返回。
.wait(timeout=None)  #等待通知或直到超时发生  return True or False
.wait_for(predicate, timeout=None)
.notify(n=1) #最多唤醒n个等待条件变量的线程
.notify_all() # 唤醒在此条件下等待的所有线程。这个方法的作用类似于通知()

# 信号量 Semaphore  P() and V() instead of acquire() and release()
# 信号量管理一个内部计数器 当acquire()发现它是零时，它会阻塞，直到其他线程调用release()。
# 支持 上下文管理协议 也就是可以用with 使用
class threading.Semaphore(value=1)  #信号量的计数器默认值为1，获取-1释放+1
.acquire(blocking=True, timeout=None)   # 计数器-1 并返回ture，计数器为0 时候则阻塞，直到release()唤醒
.release() #释放信号量，计数器+1

# 事件对象 线程之间最简单的通信机制之一：一个线程表示一个事件，另一个线程等待它。
# 事件管理一个内部flag，该标志可以用set()方法设置为true，
# 并使用clear()方法将其重置为false
# WAIT()方法会阻塞，直到标志为True为止。该标志最初是False的
class threading.Event 
.is_set() # flag = Ture 时才返回ture
.set()    # 设置flag为ture 所有等待它成变成ture的线程都被唤醒。一旦标志为true，调用wait()的线程根本不会阻塞
.clear()  # 重置flag为false  调用wait()的线程将阻塞，直到flag为ture
.wait(timeout=None)

# 屏障对象: 是一个简单的同步原语，供需要等待的固定数量的线程使用。
# 每个线程都试图通过调用WAIT()方法来通过屏障，并将阻塞，
# 直到所有线程都进行了WAIT()调用。此时，线程同时释放。
class threading.Barrier(parties, action=None, timeout=None)
wait(timeout=None)
reset()
abort()
parties
n_waiting
broken


b = Barrier(2, timeout=5)
def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

# 定时器类：经过一段时间后才能运行的操作
class threading.Timer(interval, function, args=None, kwargs=None)
.start()  # 运行定时器
.cancel() #取消运行中的定时器

example：
def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed