import threading
import time

counter = 0  # 共享變量
lock = threading.Lock()  # 創(chuàng)建鎖

def worker(n):
    global counter
    with lock:  # 獲取鎖
        local_counter = counter
        time.sleep(0.1)  # 模擬某些計算
        counter = local_counter + n
        print(f"Thread {threading.current_thread().name} updated counter to {counter}")

# 創(chuàng)建多個線程
threads = [threading.Thread(target=worker, args=(1,)) for _ in range(5)]

# 啟動線程
for t in threads:
    t.start()

# 等待所有線程完成
for t in threads:
    t.join()

print("Final counter value:", counter)

import multiprocessing
import time

counter = multiprocessing.Value('i', 0)  # 共享變量
lock = multiprocessing.Lock()  # 進(jìn)程鎖

def worker(n):
    with lock:  # 獲取鎖
        local_counter = counter.value
        time.sleep(0.1)  # 模擬某些計算
        counter.value = local_counter + n
        print(f"Process {multiprocessing.current_process().name} updated counter to {counter.value}")

# 創(chuàng)建多個進(jìn)程
processes = [multiprocessing.Process(target=worker, args=(1,)) for _ in range(5)]

# 啟動進(jìn)程
for p in processes:
    p.start()

# 等待所有進(jìn)程完成
for p in processes:
    p.join()

print("Final counter value:", counter.value)

import threading

lock = threading.RLock()

def recursive_function(n):
    if n <= 0:
        return
    with lock:  # 允許同一線程多次獲取鎖
        print(f"Acquired lock in recursion level {n}")
        recursive_function(n - 1)

recursive_function(3)

import threading
import time

semaphore = threading.Semaphore(3)  # 最多允許 3 個線程同時運(yùn)行

def worker(n):
    with semaphore:
        print(f"Thread {n} is running")
        time.sleep(2)
        print(f"Thread {n} finished")

threads = [threading.Thread(target=worker, args=(i,)) for i in range(6)]

for t in threads:
    t.start()

for t in threads:
    t.join()

import threading

condition = threading.Condition()
shared_data = None

def consumer():
    global shared_data
    with condition:
        print("Consumer waiting...")
        condition.wait()  # 等待生產(chǎn)者通知
        print(f"Consumer received: {shared_data}")

def producer():
    global shared_data
    with condition:
        shared_data = "Data ready!"
        print("Producer produced data, notifying consumer...")
        condition.notify()  # 通知消費者

t1 = threading.Thread(target=consumer)
t2 = threading.Thread(target=producer)

t1.start()
t2.start()

t1.join()
t2.join()

import threading
import time

event = threading.Event()

def worker():
    print("Worker waiting for event...")
    event.wait()  # 等待事件被 set
    print("Worker received event signal!")

def set_event():
    time.sleep(3)
    event.set()  # 觸發(fā)事件

threading.Thread(target=worker).start()
threading.Thread(target=set_event).start()