# 危險的文件操作示例
def read_large_file(file_path):
    file = open(file_path, 'r')  # 獲取文件句柄
    data = file.read()
    # 忘記調(diào)用 file.close()
    return data

# 錯誤的雙重釋放示例
class ResourceHolder:
    def __init__(self):
        self.resource = acquire_resource()
    
    def cleanup(self):
        if self.resource:
            release_resource(self.resource)
            self.resource = None

holder = ResourceHolder()
holder.cleanup()
holder.cleanup()  # 第二次調(diào)用導致異常

# 異常處理中的資源泄漏
def process_data():
    file = open('data.txt', 'r')
    db_conn = connect_to_db()
    try:
        data = file.read()
        db_conn.execute(f"INSERT INTO logs VALUES('{data}')")
    except Exception as e:
        print(f"Error occurred: {e}")
    # 無論是否發(fā)生異常，都需要關閉資源
    # 但實際代碼中經(jīng)常忘記處理

class ManagedResource:
    def __enter__(self):
        # 資源獲取邏輯
        print("Acquiring resource...")
        self.resource = acquire_expensive_resource()
        return self.resource  # 可返回不同對象
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        # 資源釋放邏輯
        print("Releasing resource...")
        if exc_type is not None:
            print(f"Handling exception: {exc_val}")
        release_resource(self.resource)

# 安全文件操作示例
def read_file_safely(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        return file.read()

# 等價于手動實現(xiàn)：
def read_file_manual(file_path):
    file = None
    try:
        file = open(file_path, 'r', encoding='utf-8')
        return file.read()
    finally:
        if file is not None:
            file.close()

# 數(shù)據(jù)庫連接池上下文管理器
class DatabaseConnection:
    def __init__(self, connection_string):
        self.connection_string = connection_string
    
    def __enter__(self):
        self.conn = psycopg2.connect(self.connection_string)
        return self.conn.cursor()
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            self.conn.commit()
        else:
            self.conn.rollback()
        self.conn.close()

# 使用示例
with DatabaseConnection("dbname=test user=postgres") as cursor:
    cursor.execute("SELECT * FROM users")
    print(cursor.fetchall())

# 線程鎖上下文管理器
from threading import Lock

class ThreadLock:
    def __init__(self):
        self.lock = Lock()
    
    def __enter__(self):
        self.lock.acquire()
        print("Lock acquired")
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.lock.release()
        print("Lock released")

# 使用示例
shared_resource = 0
lock = ThreadLock()

def increment_resource():
    global shared_resource
    with lock:
        shared_resource += 1

# 臨時文件上下文管理器
import tempfile
import os

class TemporaryDirectory:
    def __enter__(self):
        self.path = tempfile.mkdtemp()
        return self.path
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        import shutil
        shutil.rmtree(self.path)

# 使用示例
with TemporaryDirectory() as tmpdir:
    file_path = os.path.join(tmpdir, 'test.txt')
    with open(file_path, 'w') as f:
        f.write("Temporary content")
    # 退出with塊后，臨時目錄自動刪除

# 同時管理文件和數(shù)據(jù)庫連接
with open('data.txt', 'r') as file, \
     DatabaseConnection("dbname=test") as cursor:
    data = file.read()
    cursor.execute("INSERT INTO logs VALUES(%s)", (data,))

# 上下文管理器裝飾器
from functools import wraps

def contextmanager_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 模擬__enter__
        resource = func(*args, **kwargs)
        try:
            yield resource
        finally:
            # 模擬__exit__
            resource.cleanup()
    return wrapper

# 使用示例
class Resource:
    def cleanup(self):
        print("Cleaning up...")

@contextmanager_decorator
def get_resource():
    return Resource()

with get_resource() as res:
    print("Using resource...")

# 異步文件操作示例
import aiofiles

async def async_file_example():
    async with aiofiles.open('async.txt', mode='w') as f:
        await f.write("Async content")
    # 自動關閉文件

# 延遲獲取資源的上下文管理器
class LazyResource:
    def __init__(self):
        self.resource = None
    
    def __enter__(self):
        if self.resource is None:
            print("Initializing resource...")
            self.resource = acquire_expensive_resource()
        return self.resource
    
    def __exit__(self, *args):
        pass  # 不釋放資源，適合單例模式

# 區(qū)分異常類型的釋放邏輯
class FineGrainedExit:
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is ValueError:
            print("Handling ValueError")
            return True  # 抑制異常傳播
        elif exc_type is KeyboardInterrupt:
            print("Handling KeyboardInterrupt")
            return False  # 允許異常傳播
        print("Cleaning up normally")

class WrongExit:
    def __exit__(self, *args):
        return True  # 抑制所有異常！

with WrongExit():
    1 / 0  # 異常被靜默吞噬

class ValuableResource:
    def __enter__(self):
        return {"key": "value"}
    
    def __exit__(self, *args):
        pass

# 錯誤用法：忽略返回值
with ValuableResource() as res:
    print("Inside context")  # 未使用res

# 正確用法
with ValuableResource() as res:
    print(res["key"])  # 使用返回的資源

class DangerousExit:
    def __exit__(self, *args):
        if args[0] is not None:
            raise RuntimeError("Cleanup failed")  # 危險操作！

with DangerousExit():
    raise ValueError("Original error")
# 將同時存在 ValueError 和 RuntimeError

from typing import ContextManager

def process_with_resource() -> ContextManager[Resource]:
    ...

with DistributedLock("resource_key") as lock:
    # 跨多臺機器的同步操作