from multiprocessing import Process, Queue
def producer(q):
    for i in range(5):
        q.put(i)
def consumer(q):
    while True:
        data = q.get()
        print(f"消費了：{data}")
if __name__ == "__main":
    q = Queue()
    producer_process = Process(target=producer, args=(q,))
    consumer_process = Process(target=consumer, args=(q,))
    producer_process.start()
    consumer_process.start()

from multiprocessing import Process, Pipe
def sender(conn):
    conn.send("消息來自sender")
def receiver(conn):
    data = conn.recv()
    print(f"receiver接收到：{data}")
if __name__ == "__main":
    parent_conn, child_conn = Pipe()
    sender_process = Process(target=sender, args=(child_conn,))
    receiver_process = Process(target=receiver, args=(parent_conn,))
    sender_process.start()
    receiver_process.start()

from multiprocessing import Process, Queue
def data_processing(data, result_queue):
    # 進行數(shù)據(jù)處理的具體操作
    processed_data = data * 2
    result_queue.put(processed_data)
if __name__ == "__main__":
    data_to_process = [1, 2, 3, 4, 5]
    result_queue = Queue()
    processes = []
    for data in data_to_process:
        process = Process(target=data_processing, args=(data, result_queue))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()
    results = []
    while not result_queue.empty():
        results.append(result_queue.get())
    print("處理后的數(shù)據(jù):", results)

from multiprocessing.connection import Listener, Client
def server(address):
    with Listener(address) as listener:
        with listener.accept() as conn:
            print('連接來自：', listener.last_accepted)
            data = conn.recv()
            print('接收到的數(shù)據(jù):', data)
def client(address, data):
    with Client(address) as conn:
        conn.send(data)
if __name__ == '__main__':
    address = ('localhost', 6000)
    server_process = Process(target=server, args=(address,))
    server_process.start()
    client_process = Process(target=client, args=(address, "Hello, World!"))
    client_process.start()
    server_process.join()
    client_process.join()

from multiprocessing import Process, Queue
def producer(q):
    for item in range(5):
        q.put(item)
def consumer(q):
    while True:
        item = q.get()
        print(f"消費了：{item}")
if __name__ == '__main__':
    q = Queue()
    producer_process = Process(target=producer, args=(q,))
    consumer_process = Process(target=consumer, args=(q))
    producer_process.start()
    consumer_process.start()
    producer_process.join()
    consumer_process.terminate()

from multiprocessing import Process, Lock

def task(lock, data):
    lock.acquire()
    try:
        # 執(zhí)行需要同步的操作
        print(f"處理數(shù)據(jù)：{data}")
    finally:
        lock.release()

if __name__ == '__main__':
    lock = Lock()
    processes = []

    for i in range(5):
        p = Process(target=task, args=(lock, i))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

# 選擇合適的通信方式
from multiprocessing import Process, Queue, Pipe, Value

# 使用Queue
def using_queue(q):
    q.put("數(shù)據(jù)")

# 使用Pipe
def using_pipe(conn):
    conn.send("數(shù)據(jù)")

# 使用Shared Memory
def using_shared_memory(shared_val):
    shared_val.value = 10

if __name__ == '__main':
    q = Queue()
    parent_conn, child_conn = Pipe()
    shared_val = Value('i', 0)

    queue_process = Process(target=using_queue, args=(q,))
    pipe_process = Process(target=using_pipe, args=(child_conn,))
    shared_memory_process = Process(target=using_shared_memory, args=(shared_val,))

    # 啟動進程
    queue_process.start()
    pipe_process.start()
    shared_memory_process.start()