Producer-Consumer-Problem bei der Verwendung von Multiprocessing in Python ⇐ Python

[Guest]

Ich versuche, dieses Problem mithilfe von Multiprocessing und Pipe als Kommunikationsstrategie zwischen Prozessen mithilfe der folgenden Methode zu implementieren:
Der Produzent hat einen pro_count.

Dies ist ein Zähler, der die Anzahl der Artikel im Puffer zählt.

Wenn der Produzent einen Artikel produziert, legt er diesen Artikel in den Puffer und benachrichtigt den Verbraucher über die Ausgabepipeline darüber, dass er einen Artikel produziert hat.

Dann addiert es 1 zu der pro_count, weil ein Artikel in den Puffer gestellt wird.

Hier gibt es eine weitere Pipe, die notify_pipe, und der Verbraucher benachrichtigt den Produzenten über diese Pipe, dass er einen Artikel verbraucht hat und wenn ein Artikel verbraucht wird bedeutet, dass ein Element aus dem Puffer entnommen wird, sodass 1 von pro_count abgezogen wird.

Wenn pro_count gleich oder größer als buffer_size ist, bedeutet dies, dass der Puffer voll ist und warten muss, bis der Verbraucher verbraucht ein Artikel von der Puffer und dann hat er die Kapazität und dann kann der Produzent ein Element in den Puffer legen.
Auf der Verbraucherseite hat der Verbraucher einen con_count.

Dies ist ein Zähler, der die Anzahl der Artikel im Puffer zählt.

Wenn der Produzent einen Artikel produziert, legt er diesen Artikel in den Puffer und benachrichtigt den Verbraucher über die Ausgabepipeline darüber, dass er einen Artikel produziert hat.

Dann wird 1 zum hinzugefügt con_count, weil ein Artikel in den Puffer gestellt wird.

Hier gibt es eine weitere Pipe, die notify_pipe, und der Verbraucher benachrichtigt den Produzenten über diese Pipe, dass er einen Artikel verbraucht hat und wann ein Artikel verbraucht ist dass ein Element aus dem Puffer entnommen wird, sodass 1 von con_count abgezogen wird.

Wenn con_count gleich Null wird, bedeutet dies, dass der Puffer leer ist und warten muss, bis der Produzent ein Element produziert in den Puffer geben und dann es kann es verbrauchen.

Wenn der Produzent aufgrund eines vollen Puffers und der Verbraucher aufgrund eines leeren Puffers wartet, muss dies nicht nur im Terminal angezeigt werden, sondern er muss auch tatsächlich im System warten .
Dieses Programm muss außerdem drei Bedingungen aufweisen.
Eine davon ist, dass Produzent und Verbraucher gleichzeitig arbeiten, was wir mit Close Sleep umsetzen können mal (als ob beide 1 wären).
Die andere Bedingung ist, dass die vollständige Puffer passiert tatsächlich und der Produzent wartet darauf, dass die Ruhezeit des Produzenten viel kürzer ist als die Ruhezeit des Konsumenten (Ruhezeit des Produzenten: 0,01, Ruhezeit des Konsumenten: 1)
und die andere Bedingung ist, dass der leere Puffer tatsächlich auftreten muss, was meiner Meinung nach so sein kann: ( Ruhezeit des Produzenten: 1, Ruhezeit des Verbrauchers: 0,01).
Ich habe den folgenden Code geschrieben, aber das Problem ist, dass es nicht funktioniert und im Terminal nichts angezeigt wird. Ich denke, meine Logik war richtig und ich habe viel gesucht, um herauszufinden, wo das Problem liegt, aber ich konnte es immer noch nicht beheben. der Code:
'''

Code: Select all

from multiprocessing import Process, Pipe, Lock, Condition
import time
import random

# Define buffer size and shared buffer
buffer_size = 30
buffer = []

def create_items(pipe_1, notify_pipe, lock, condition):

output_pipe = pipe_1[1]
notify_conn = notify_pipe[0]
pro_counter = 0

for _ in range(100):
item = random.randint(0, 1000)

# Producer waits if buffer is full
with condition:
while pro_counter >= buffer_size:  # Wait until there's space in the buffer
print("Producer waiting: Buffer full.")
condition.wait()  # Wait for consumer to consume an item

#Add the item to the buffer
with lock:
buffer.append(item)
pro_counter += 1
print(f"Producer: Producing {item}")
output_pipe.send("produced")  # Notify consumer an item was produced

# Notify consumer that an item was produced
#condition.notify_all()

# Process acknowledgments from the consumer
while notify_conn.poll():
ack = notify_conn.recv()
if ack == "consumed":
pro_counter -= 1

time.sleep(0.01)  # Simulate some delay

# Signal the consumer that production is complete
output_pipe.send(None)
output_pipe.close()

def consume_items(pipe_1, notify_pipe, lock, condition):

input_pipe = pipe_1[0]
notify_conn = notify_pipe[1]
con_counter = 0

while True:

ack = input_pipe.recv()
if ack == "produced":
con_counter += 1

with condition:
while con_counter