Python 线程条件变量 Condition - Python零基础入门教程

最新推荐文章于 2024-09-29 09:46:58 发布

猿说编程

最新推荐文章于 2024-09-29 09:46:58 发布

阅读量662

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Python基础入门文章标签： Python线程条件变量 Python线程 Python条件变量线程Condition 猿说编程

本文链接：https://blog.csdn.net/ZhaDeNianQu/article/details/118177754

Python基础入门专栏收录该内容

74 篇文章

订阅专栏

本文详细介绍了Python线程条件变量Condition的使用，包括acquire、release、wait、notify和notifyAll等函数。通过成语接龙和生产者消费者模式的案例，展示了Condition如何实现线程间的通信和同步，强调了其在复杂线程交互中的作用。

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

一.Python 线程条件变量 Condition 函数
二.Python 线程条件变量 Condition 原理
三.Python 线程条件变量 Condition 使用
四.Python 线程条件变量 Condition 总结
五.猜你喜欢

零基础 Python 学习路线推荐 : Python 学习目录 >> Python 基础入门

对于线程与线程之间的交互我们在前面的文章已经介绍了 Python 互斥锁 Lock / Python 事件 Event , 今天继续介绍一种线程交互方式 – 线程条件变量 Condition；

一.Python 线程条件变量 Condition 函数

acquire — 线程锁，注意线程条件变量 Condition 中的所有相关函数使用必须在acquire / release 内部操作；
release — 释放锁，注意线程条件变量 Condition 中的所有相关函数使用必须在acquire / release 内部操作；
**wait( timeout ) **— 线程挂起(阻塞状态)，直到收到一个 notify 通知或者超时才会被唤醒继续运行（超时参数默认不设置，可选填，类型是浮点数，单位是秒）。wait 必须在已获得 Lock 前提下才能调用，否则会触发 RuntimeError；
**notify(n=1) **— 通知其他线程，那些挂起的线程接到这个通知之后会开始运行，缺省参数，默认是通知一个正等待通知的线程,最多则唤醒 n 个等待的线程。 notify 必须在已获得 Lock 前提下才能调用，否则会触发 RuntimeError ，notify 不会主动释放 Lock ；
notifyAll — 如果 wait 状态线程比较多，notifyAll 的作用就是通知所有线程；

二.Python 线程条件变量 Condition 原理

Python 互斥锁 Lock，主要作用是并行访问共享资源时，保护共享资源，防止出现脏数据。

Python 条件变量 Condition 也需要关联互斥锁，同时 Condition 自身提供了 wait / notify / notifyAll 方法，用于阻塞 / 通知其他并行线程，可以访问共享资源了。

可以这么理解，Condition 提供了一种多线程通信机制，假如线程 1 需要数据，那么线程 1 就阻塞等待，这时线程 2 就去制造数据，线程 2 制造好数据后，通知线程 1 可以去取数据了，然后线程 1 去获取数据。

三.Python 线程条件变量 Condition 使用

案例一：成语接龙

# !usr/bin/env python
# -*- coding:utf-8 _*-
"""
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 线程条件变量 Condition.py
@Time:2021/05/04 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

"""

# 导入线程模块
import threading

# 创建条件变量condition
con = threading.Condition()

def thread_one(name):
    # 条件变量condition 线程上锁
    con.acquire()

    print("{}:成语接龙准备好了吗".format(name))
    # 唤醒正在等待(wait)的线程
    con.notify()

    # 等待对方回应消息，使用wait阻塞线程，等待对方通过notify唤醒本线程
    con.wait()
    print("{}:一干二净".format(name))
    # 唤醒对方
    con.notify()

    # 等待消息答应
    con.wait()
    print("{}:一天就知道看抖音美女，给你来个简单点的，来了：毛手毛脚".format(name))
    # 唤醒对方
    con.notify()

    # 等待消息答应
    con.wait()
    print("{}:哟哟哟，不错不错！".format(name))
    # 唤醒对方
    con.notify()

    # 条件变量condition 线程释放锁
    con.release()

def thread_two(name):
    # 条件变量condition 线程上锁
    con.acquire()

    # wait阻塞状态，等待其他线程通过notify唤醒本线程
    con.wait()
    print("{}:准备好了~开始吧！".format(name))
    # 唤醒对方
    con.notify()

    # 等待消息答应
    con.wait()
    print("{}:净你妹啊，没法接...来个简单点的...".format(name))
    # 唤醒对方
    con.notify()

    # 等待消息答应
    con.wait()
    print("{}:嘿,这个我知道：脚踏实地".format(name))
    # 唤醒对方
    con.notify()

    con.release()

if __name__ == "__main__":

    # 创建并初始化线程
    t1 = threading.Thread(target=thread_one,args=("A"))
    t2 = threading.Thread(target=thread_two,args=("B"))

    # 启动线程 -- 注意线程启动顺序，启动顺序很重要
    t2.start()
    t1.start()

    # 阻塞主线程，等待子线程结束
    t1.join()
    t2.join()


    print("程序结束！")


'''
输出结果：

A:成语接龙准备好了吗
B:准备好了~开始吧！
A:一干二净
B:净你妹啊，没法接...来个简单点的...
A:一天就知道看抖音美女，给你来个简单点的，来了：毛手毛脚
B:嘿,这个我知道：脚踏实地
A:哟哟哟，不错不错！
程序结束！
'''

案例二：生产者与消费者模式，以吃火锅为例：一盘老肉片有 10 块肉，吃完了又重新往锅里加….

生产者：往锅里加老肉片，每次加一盘(10 块)；
消费者：吃煮熟的肉片，没吃一片，肉片数量减一，吃完为止;

# !usr/bin/env python
# -_- coding:utf-8 \__-

  """
  @Author:猿说编程
  @Blog(个人博客地址): www.codersrc.com
  @File:Python 线程条件变量 Condition.py
  @Time:2021/05/04 07:37
  @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

  """

  #  导入线程模块
  import threading
  import time

  #  创建条件变量 condition
  con = threading.Condition()
  meat_num = 0

  def thread_consumers():
      #  条件变量 condition  线程上锁
      con.acquire()

  #  全局变量声明关键字  global
      global meat_num
      meat_num = 0

  #  等待肉片下锅煮熟
      con.wait()
      while True:
          print("我来一块肉片...")
          meat_num -= 1
          print("剩余肉片数量：%d"%meat_num)
          time.sleep(0.5)
          if meat_num == 0:
              #  肉片吃光了，通知老板添加肉片
              print("老板，再来一份老肉片...")
              con.notify()
              #  肉片吃光了，等待肉片
              con.wait()

  #  条件变量 condition  线程释放锁
      con.release()

  def thread_producer():
      #  条件变量 condition  线程上锁
      con.acquire()
      #  全局变量声明关键字  global
      global meat_num

  #  肉片熟了，可以开始吃了
      meat_num = 10
      print("肉片熟了，可以开始吃了...")
      con.notify()
      while True:
          #  阻塞函数,等待肉片吃完的通知
          con.wait()
          meat_num = 10
          #  添加肉片完成，可以继续开吃
          print("添加肉片成功！当前肉片数量：%d"%meat_num)
          time.sleep(1)
          con.notify()

  con.release()

  if **name** == "**main**":
      #  创建并初始化线程
      t1 = threading.Thread(target=thread_producer)
      t2 = threading.Thread(target=thread_consumers)

  #  启动线程  --  注意线程启动顺序，启动顺序很重要
      t2.start()
      t1.start()

  #  阻塞主线程，等待子线程结束
      t1.join()
      t2.join()

  print("程序结束！")

  '''
  输出结果：

  肉片熟了，可以开始吃了...
  我来一块肉片...
  剩余肉片数量：9
  我来一块肉片...
  剩余肉片数量：8
  我来一块肉片...
  剩余肉片数量：7
  我来一块肉片...
  剩余肉片数量：6
  我来一块肉片...
  剩余肉片数量：5
  我来一块肉片...
  剩余肉片数量：4
  我来一块肉片...
  剩余肉片数量：3
  我来一块肉片...
  剩余肉片数量：2
  我来一块肉片...
  剩余肉片数量：1
  我来一块肉片...
  剩余肉片数量：0
  老板，再来一份老肉片...
  添加肉片成功！当前肉片数量：10
  我来一块肉片...
  剩余肉片数量：9
  我来一块肉片...
  剩余肉片数量：8
  我来一块肉片...
  剩余肉片数量：7
  .............
  '''