Python Condition acquire()用法及代码示例

Python Condition.acquire() 方法

acquire() 是 Python 中线程模块的 Condition 类的内置方法。

条件类实现条件变量对象。条件变量允许一个或多个线程等待，直到它们被另一个线程通知。 Acquire 方法用于获取锁。它调用底层锁上的相应方法并返回方法值。

Producer-Consumer 问题是多线程中 Condition 对象的完美用例。在这个问题中，有一个生产者生产某种物品，一个消费者消费该物品。在生产者还没有生产物品之前，消费者不能消费它。因此，它等待 Producer 生产项目。此外，生产者有责任通知消费者某物品已生产并可供消费。如果有多个消费者，那么生产者必须将新项目通知所有消费者。

模块：

    from threading import Condition 

用法:

    acquire(*args)

参数：

• args: 它是一个可选参数，指定我们可以放入 acquire() 方法的参数。

返回值：

这个方法的返回类型是<class 'bool'>.该方法用于在实现多线程时获取锁，如果成功获取锁则返回 True，否则返回 False。

例：

# use of acquire() method for Condition object

import threading
import time
import random

class subclass:
  # Initialising the shared resources
  def __init__(self):
    self.x = []
  
  # Add an item for the producer
  def produce_item(self, x_item):
    print("Producer adding an item to the list")
    self.x.append(x_item)
    
  # Consume an item for the consumer
  def consume_item(self):
    print("Consuming from the list")
    consumed_item = self.x[0]
    print("Consumed item:", consumed_item)
    self.x.remove(consumed_item)

def producer(subclass_obj, condition_obj):
    # Selecting a random number from the 1 to 3
    r = random.randint(1,3)
    print("Random number selected was:", r)
    
    # Creting r number of items by the producer
    for i in range(1, r):
      print("Producing an item, time it will take(seconds):" + str(i))
      time.sleep(i)
      
      print("Producer acquiring the lock")
      condition_obj.acquire()
      try:
        # Produce an item
        subclass_obj.produce_item(i)
        # Notify that an item  has been produced
        condition_obj.notify()
      finally:
        # Releasing the lock after producing
        condition_obj.release()
      
def consumer(subclass_obj, condition_obj):
    condition_obj.acquire()
    while True:
      try:
        # Consume the item 
        subclass_obj.consume_item()
      except:
        print("No item to consume, list empty")
        print("Waiting for 10 seconds")
        # wait with a maximum timeout of 10 sec
        value = condition_obj.wait(10)
        if value:
          print("Item produced notified")
          continue
        else:
          print("Waiting timeout")
          break
        
    # Releasig the lock after consuming
    condition_obj.release()
    
if __name__=='__main__':
    
  # Initialising a condition class object
  condition_obj = threading.Condition()
  # subclass object
  subclass_obj = subclass()
  
  # Producer thread
  pro = threading.Thread(target=producer, args=(subclass_obj,condition_obj,))
  pro.start()
  
  # consumer thread
  con = threading.Thread(target=consumer, args=(subclass_obj,condition_obj,))
  con.start()

  pro.join()
  con.join()
  print("Producer Consumer code executed")

输出：

Random number selected was:3
Producing an item, time it will take(seconds):1
Consuming from the list
No item to consume, list empty
Waiting for 10 seconds
Producer acquiring the lock
Producer adding an item to the list
Item produced notified
Consuming from the list
Consumed item: 1
Consuming from the list
No item to consume, list empty
Waiting for 10 seconds
Producing an item, time it will take(seconds):2
Producer acquiring the lock
Producer adding an item to the list
Item produced notified
Consuming from the list
Consumed item: 2
Consuming from the list
No item to consume, list empty
Waiting for 10 seconds
Waiting timeout
Producer Consumer code executed