import threading

# 創(chuàng)建鎖
lock = threading.Lock()
shared_data = 0

def increment():
    global shared_data
    for _ in range(100000):
        # 獲取鎖
        lock.acquire()
        try:
            shared_data += 1
        finally:
            # 釋放鎖
            lock.release()

# 使用 with 語句更安全
def increment_safe():
    global shared_data
    for _ in range(100000):
        with lock:  # 自動(dòng)獲取和釋放鎖
            shared_data += 1

# 創(chuàng)建線程
t1 = threading.Thread(target=increment_safe)
t2 = threading.Thread(target=increment_safe)

t1.start()
t2.start()
t1.join()
t2.join()

print(f"最終結(jié)果: {shared_data}")  # 應(yīng)該是 200000

import threading

rlock = threading.RLock()

def recursive_func(n):
    with rlock:
        print(f"Entering Level {n}")
        if n > 0:
            recursive_func(n - 1)
        print(f"Exiting Level {n}")

print("Starting thread with recursive RLock example")
thread = threading.Thread(target=recursive_func, args=(3,))
thread.start()
thread.join()
print("Thread completed successfully")

import threading
import time

# 最多允許3個(gè)線程同時(shí)訪問
sem = threading.Semaphore(3)

def access_resource(thread_id):
    print(f"Thread {thread_id} is waiting to access")
    with sem:
        print(f"Thread {thread_id} has acquired the semaphore and is working")
        time.sleep(1)
        print(f"Thread {thread_id} is releasing the semaphore")

print("Starting threads with semaphore limit of 3...")
threads = []
for i in range(10):
    t = threading.Thread(target=access_resource, args=(i,))
    threads.append(t)
    t.start()
    time.sleep(0.1)  # 稍微延遲創(chuàng)建線程，便于觀察

for t in threads:
    t.join()

print("All threads completed")

import threading
import time

# 創(chuàng)建一個(gè)有界信號(hào)量，最多允許3個(gè)線程同時(shí)訪問
bounded_sem = threading.BoundedSemaphore(3)

def normal_access(thread_id):
    """正常使用有界信號(hào)量的函數(shù)"""
    print(f"Thread {thread_id} is waiting to access")
    with bounded_sem:
        print(f"Thread {thread_id} has acquired the bounded semaphore and is working")
        time.sleep(1)
        print(f"Thread {thread_id} is releasing the bounded semaphore")

def demonstrate_bounded_semaphore_error():
    """演示有界信號(hào)量防止過度釋放的特性"""
    print("\n演示BoundedSemaphore防止過度釋放的特性:")
    # 先獲取信號(hào)量
    print("嘗試獲取信號(hào)量...")
    bounded_sem.acquire()
    print("信號(hào)量獲取成功")
    
    # 正常釋放一次
    print("正常釋放一次信號(hào)量...")
    bounded_sem.release()
    print("信號(hào)量正常釋放")
    
    # 嘗試過度釋放
    try:
        print("嘗試過度釋放信號(hào)量(這將引發(fā)ValueError異常)...")
        bounded_sem.release()  # 這里會(huì)拋出ValueError
        print("如果看到這條消息，說明有界信號(hào)量沒有正常工作！")
    except ValueError as e:
        print(f"成功捕獲異常: {e}")
        print("這證明BoundedSemaphore可以防止過度釋放的情況發(fā)生")

print("=== 有界信號(hào)量(BoundedSemaphore)示例程序 ===")
print("1. 首先運(yùn)行多線程正常訪問的場(chǎng)景")

# 創(chuàng)建并啟動(dòng)多個(gè)線程
threads = []
for i in range(5):
    t = threading.Thread(target=normal_access, args=(i,))
    threads.append(t)
    t.start()
    time.sleep(0.2)  # 稍微延遲創(chuàng)建線程，便于觀察

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

print("\n所有線程完成正常訪問")

# 演示有界信號(hào)量的錯(cuò)誤檢測(cè)功能
demonstrate_bounded_semaphore_error()

print("\n=== 程序結(jié)束 ===")

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
生產(chǎn)者-消費(fèi)者模型實(shí)現(xiàn)

本程序演示使用threading.Condition（條件變量）實(shí)現(xiàn)經(jīng)典的生產(chǎn)者-消費(fèi)者模型。
生產(chǎn)者線程生成隨機(jī)數(shù)并放入固定大小的緩沖區(qū)，消費(fèi)者線程從緩沖區(qū)取出數(shù)據(jù)。
當(dāng)緩沖區(qū)滿時(shí)，生產(chǎn)者等待；當(dāng)緩沖區(qū)空時(shí)，消費(fèi)者等待。
"""

import threading
import time
import random

# 共享緩沖區(qū)，用于存儲(chǔ)生產(chǎn)者生產(chǎn)的物品
buffer = []

# 緩沖區(qū)最大容量
MAX_SIZE = 10

# 創(chuàng)建條件變量，用于線程間通信和同步
# Condition內(nèi)部維護(hù)一個(gè)鎖，提供wait()、notify()等方法進(jìn)行線程協(xié)作
condition = threading.Condition()

class Producer(threading.Thread):
    """
    生產(chǎn)者類，繼承自threading.Thread
    負(fù)責(zé)生成隨機(jī)數(shù)并添加到緩沖區(qū)
    """
    def run(self):
        """
        線程運(yùn)行方法
        使用條件變量確保線程安全的緩沖區(qū)訪問
        """
        global buffer
        
        # 無限循環(huán)生產(chǎn)物品
        while True:
            # 獲取條件變量的鎖
            with condition:
                # 檢查緩沖區(qū)是否已滿
                # 注意：此處應(yīng)使用while循環(huán)而非if語句，防止虛假喚醒
                while len(buffer) == MAX_SIZE:
                    print("Buffer full, producer waiting")
                    # 釋放鎖并等待，直到被其他線程通知
                    condition.wait()
                
                # 生產(chǎn)一個(gè)隨機(jī)物品
                item = random.randint(1, 100)
                # 將物品添加到緩沖區(qū)
                buffer.append(item)
                print(f"Produced {item}, buffer: {buffer}")
                
                # 通知一個(gè)等待的消費(fèi)者線程
                condition.notify()
            
            # 生產(chǎn)間隔隨機(jī)時(shí)間，模擬生產(chǎn)過程
            time.sleep(random.random())

class Consumer(threading.Thread):
    """
    消費(fèi)者類，繼承自threading.Thread
    負(fù)責(zé)從緩沖區(qū)取出物品進(jìn)行消費(fèi)
    """
    def run(self):
        """
        線程運(yùn)行方法
        使用條件變量確保線程安全的緩沖區(qū)訪問
        """
        global buffer
        
        # 無限循環(huán)消費(fèi)物品
        while True:
            # 獲取條件變量的鎖
            with condition:
                # 檢查緩沖區(qū)是否為空
                # 同樣使用while循環(huán)防止虛假喚醒
                while not buffer:
                    print("Buffer empty, consumer waiting")
                    # 釋放鎖并等待，直到被其他線程通知
                    condition.wait()
                
                # 從緩沖區(qū)取出第一個(gè)物品（FIFO原則）
                item = buffer.pop(0)
                print(f"Consumed {item}, buffer: {buffer}")
                
                # 通知一個(gè)等待的生產(chǎn)者線程
                condition.notify()
            
            # 消費(fèi)間隔隨機(jī)時(shí)間，模擬消費(fèi)過程
            time.sleep(random.random())

# 程序入口點(diǎn)
if __name__ == "__main__":
    print("生產(chǎn)者-消費(fèi)者模型演示程序啟動(dòng)...")
    print(f"緩沖區(qū)最大容量: {MAX_SIZE}")
    
    # 創(chuàng)建并啟動(dòng)生產(chǎn)者線程
    Producer().start()
    
    # 創(chuàng)建并啟動(dòng)消費(fèi)者線程
    Consumer().start()
    
    print("線程已啟動(dòng)，按Ctrl+C停止程序")

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Threading.Event示例程序

本程序演示了Python中threading.Event的基本用法。
Event對(duì)象是線程間同步的一種機(jī)制，類似于一個(gè)信號(hào)標(biāo)志，
可以控制線程的執(zhí)行和等待狀態(tài)。
"""

import threading
import time

# 創(chuàng)建Event對(duì)象，初始狀態(tài)為False
event = threading.Event()

def waiter():
    """
    等待者線程函數(shù)
    
    該函數(shù)模擬一個(gè)需要等待某個(gè)事件發(fā)生才能繼續(xù)執(zhí)行的線程
    當(dāng)event被設(shè)置（set）時(shí)，wait()方法才會(huì)解除阻塞
    """
    print("Waiter: waiting for event")
    # 阻塞當(dāng)前線程，直到event被設(shè)置
    event.wait()  # 阻塞直到事件被設(shè)置
    print("Waiter: event received, proceeding")

def setter():
    """
    設(shè)置者線程函數(shù)
    
    該函數(shù)模擬一個(gè)在某個(gè)時(shí)刻觸發(fā)事件的線程
    通過調(diào)用event.set()方法，將事件標(biāo)志設(shè)置為True，
    喚醒所有等待該事件的線程
    """
    # 模擬耗時(shí)操作
    time.sleep(2)
    print("Setter: setting event")
    # 設(shè)置事件，喚醒所有等待的線程
    event.set()  # 設(shè)置事件，喚醒所有等待的線程

# 創(chuàng)建并啟動(dòng)等待者線程
threading.Thread(target=waiter).start()
# 創(chuàng)建并啟動(dòng)設(shè)置者線程
threading.Thread(target=setter).start()