// C語言中的手動內(nèi)存管理
#include <stdlib.h>

int main() {
    int *arr = (int*)malloc(10 * sizeof(int));  // 手動分配內(nèi)存
    if (arr == NULL) {
        return -1;  // 內(nèi)存分配失敗處理
    }
    
    // 使用內(nèi)存...
    for (int i = 0; i < 10; i++) {
        arr[i] = i;
    }
    
    free(arr);  // 手動釋放內(nèi)存
    return 0;
}

# Python中的自動內(nèi)存管理
def process_data():
    # 自動分配內(nèi)存
    data = [i for i in range(1000000)]
    result = [x * 2 for x in data]
    
    # 不需要手動釋放內(nèi)存
    return result

# 函數(shù)結(jié)束后，不再使用的內(nèi)存會被自動回收

# memory_architecture.py
import sys
import os
from typing import Dict, List, Any
import ctypes

class MemoryArchitecture:
    """Python內(nèi)存架構(gòu)分析"""
    
    def __init__(self):
        self.memory_layers = {
            "application_layer": {
                "description": "Python對象層 - 開發(fā)者直接接觸的層面",
                "components": ["對象創(chuàng)建", "引用管理", "生命周期"],
                "responsibility": "對象的創(chuàng)建和引用管理"
            },
            "interpreter_layer": {
                "description": "Python解釋器層 - CPython實現(xiàn)",
                "components": ["PyObject", "類型系統(tǒng)", "引用計數(shù)"],
                "responsibility": "對象表示和基礎(chǔ)內(nèi)存管理"
            },
            "memory_allocator_layer": {
                "description": "內(nèi)存分配器層 - Python內(nèi)存分配策略",
                "components": ["對象分配器", "小塊內(nèi)存分配", "內(nèi)存池"],
                "responsibility": "高效的內(nèi)存分配和回收"
            },
            "system_layer": {
                "description": "操作系統(tǒng)層 - 底層內(nèi)存管理",
                "components": ["malloc/free", "虛擬內(nèi)存", "物理內(nèi)存"],
                "responsibility": "物理內(nèi)存的分配和管理"
            }
        }
    
    def analyze_memory_usage(self):
        """分析當(dāng)前內(nèi)存使用情況"""
        import gc
        
        print("=== Python內(nèi)存架構(gòu)分析 ===")
        
        # 各層內(nèi)存使用分析
        for layer, info in self.memory_layers.items():
            print(f"\n{layer.upper()}層:")
            print(f"  描述: {info['description']}")
            print(f"  組件: {', '.join(info['components'])}")
        
        # 當(dāng)前內(nèi)存統(tǒng)計
        print(f"\n當(dāng)前內(nèi)存統(tǒng)計:")
        print(f"  進程內(nèi)存使用: {self._get_process_memory():.2f} MB")
        print(f"  Python對象數(shù)量: {len(gc.get_objects())}")
        print(f"  垃圾回收器跟蹤對象: {len(gc.get_tracked_objects())}")
    
    def _get_process_memory(self):
        """獲取進程內(nèi)存使用"""
        import psutil
        process = psutil.Process(os.getpid())
        return process.memory_info().rss / 1024 / 1024  # MB

# 使用示例
architecture = MemoryArchitecture()
architecture.analyze_memory_usage()

# object_representation.py
import sys
import struct
from dataclasses import dataclass
from typing import Any

class ObjectMemoryLayout:
    """Python對象內(nèi)存布局分析"""
    
    @staticmethod
    def analyze_object(obj: Any) -> Dict[str, Any]:
        """分析對象的內(nèi)存布局"""
        obj_type = type(obj)
        obj_id = id(obj)
        obj_size = sys.getsizeof(obj)
        
        # 獲取對象的引用計數(shù)（僅CPython有效）
        ref_count = ObjectMemoryLayout._get_ref_count(obj)
        
        return {
            "type": obj_type.__name__,
            "id": obj_id,
            "size": obj_size,
            "ref_count": ref_count,
            "memory_address": hex(obj_id)
        }
    
    @staticmethod
    def _get_ref_count(obj: Any) -> int:
        """獲取對象的引用計數(shù)"""
        # 注意：這僅適用于CPython實現(xiàn)
        return ctypes.c_long.from_address(id(obj)).value
    
    @staticmethod
    def compare_objects(*objects: Any) -> List[Dict[str, Any]]:
        """比較多個對象的內(nèi)存特性"""
        results = []
        for obj in objects:
            analysis = ObjectMemoryLayout.analyze_object(obj)
            results.append(analysis)
        return results
    
    @staticmethod
    def demonstrate_memory_layout():
        """演示不同對象的內(nèi)存布局"""
        print("=== Python對象內(nèi)存布局演示 ===")
        
        # 創(chuàng)建不同類型的對象
        objects = [
            42,                    # 整數(shù)
            3.14159,              # 浮點數(shù)
            "Hello, World!",      # 字符串
            [1, 2, 3, 4, 5],      # 列表
            {"key": "value"},     # 字典
            (1, 2, 3),            # 元組
            {1, 2, 3}             # 集合
        ]
        
        results = ObjectMemoryLayout.compare_objects(*objects)
        
        for result in results:
            print(f"\n{result['type']}:")
            print(f"  內(nèi)存地址: {result['memory_address']}")
            print(f"  大小: {result['size']} 字節(jié)")
            print(f"  引用計數(shù): {result['ref_count']}")

# PyObject結(jié)構(gòu)模擬（概念性）
class PyObject:
    """模擬CPython中PyObject的基本結(jié)構(gòu)"""
    
    def __init__(self, obj_type, value):
        self.ob_refcnt = 1  # 引用計數(shù)
        self.ob_type = obj_type  # 類型指針
        self.ob_value = value  # 實際值
        
    def __repr__(self):
        return f"PyObject(type={self.ob_type}, refcnt={self.ob_refcnt}, value={self.ob_value})"

# 使用示例
if __name__ == "__main__":
    ObjectMemoryLayout.demonstrate_memory_layout()
    
    # 演示PyObject概念
    print("\n=== PyObject概念演示 ===")
    int_obj = PyObject("int", 42)
    str_obj = PyObject("str", "hello")
    
    print(f"整數(shù)對象: {int_obj}")
    print(f"字符串對象: {str_obj}")

# reference_counting.py
import sys
import ctypes
from typing import List, Dict, Any

class ReferenceCountingDemo:
    """引用計數(shù)機制演示"""
    
    def __init__(self):
        self.reference_events = []
    
    def track_references(self, obj: Any, description: str) -> None:
        """跟蹤對象的引用變化"""
        current_count = self._get_ref_count(obj)
        event = {
            "description": description,
            "ref_count": current_count,
            "object_id": id(obj),
            "object_type": type(obj).__name__
        }
        self.reference_events.append(event)
        
        print(f"{description}: 引用計數(shù) = {current_count}")
    
    def _get_ref_count(self, obj: Any) -> int:
        """安全地獲取引用計數(shù)"""
        try:
            # 注意：這僅適用于CPython
            return ctypes.c_long.from_address(id(obj)).value
        except:
            # 對于其他Python實現(xiàn)，返回估計值
            return -1
    
    def demonstrate_basic_reference_counting(self):
        """演示基礎(chǔ)引用計數(shù)"""
        print("=== 基礎(chǔ)引用計數(shù)演示 ===")
        
        # 創(chuàng)建新對象
        my_list = [1, 2, 3]
        self.track_references(my_list, "創(chuàng)建列表")
        
        # 增加引用
        list_ref = my_list
        self.track_references(my_list, "創(chuàng)建另一個引用")
        
        # 在數(shù)據(jù)結(jié)構(gòu)中引用
        container = [my_list]
        self.track_references(my_list, "添加到另一個列表")
        
        # 減少引用
        del list_ref
        self.track_references(my_list, "刪除一個引用")
        
        # 從數(shù)據(jù)結(jié)構(gòu)中移除
        container.clear()
        self.track_references(my_list, "從容器中移除")
        
        # 最后刪除原始引用
        del my_list
    
    def demonstrate_function_references(self):
        """演示函數(shù)中的引用計數(shù)"""
        print("\n=== 函數(shù)中的引用計數(shù) ===")
        
        def process_data(data):
            self.track_references(data, "函數(shù)參數(shù)接收")
            result = [x * 2 for x in data]
            self.track_references(data, "函數(shù)內(nèi)部使用")
            return result
        
        data = [1, 2, 3, 4, 5]
        self.track_references(data, "函數(shù)調(diào)用前")
        
        result = process_data(data)
        self.track_references(data, "函數(shù)返回后")
        
        return data, result
    
    def analyze_reference_cycles(self):
        """分析循環(huán)引用"""
        print("\n=== 循環(huán)引用分析 ===")
        
        # 創(chuàng)建循環(huán)引用
        class Node:
            def __init__(self, value):
                self.value = value
                self.next = None
        
        # 創(chuàng)建兩個節(jié)點并形成循環(huán)引用
        node1 = Node(1)
        node2 = Node(2)
        
        self.track_references(node1, "創(chuàng)建node1")
        self.track_references(node2, "創(chuàng)建node2")
        
        # 形成循環(huán)引用
        node1.next = node2
        node2.next = node1
        
        self.track_references(node1, "形成循環(huán)引用后 - node1")
        self.track_references(node2, "形成循環(huán)引用后 - node2")
        
        # 刪除外部引用
        del node1
        del node2
        
        print("注意：雖然刪除了外部引用，但由于循環(huán)引用，對象不會被立即釋放")

# 引用計數(shù)數(shù)學(xué)原理
class ReferenceCountingTheory:
    """引用計數(shù)的數(shù)學(xué)原理"""
    
    @staticmethod
    def calculate_memory_lifetime(ref_count_history: List[int]) -> float:
        """
        計算對象的內(nèi)存生命周期
        基于引用計數(shù)的變化模式
        """
        if not ref_count_history:
            return 0.0
        
        # 簡單的生命周期估算：基于引用計數(shù)變化的頻率和幅度
        changes = 0
        total_change_magnitude = 0
        
        for i in range(1, len(ref_count_history)):
            change = abs(ref_count_history[i] - ref_count_history[i-1])
            if change > 0:
                changes += 1
                total_change_magnitude += change
        
        if changes == 0:
            return float('inf')  # 引用計數(shù)不變，對象長期存在
        
        # 平均變化幅度越大，生命周期可能越短
        avg_change = total_change_magnitude / changes
        estimated_lifetime = 100.0 / avg_change  # 簡化模型
        
        return estimated_lifetime
    
    @staticmethod
    def demonstrate_reference_counting_formula():
        """演示引用計數(shù)的數(shù)學(xué)公式"""
        print("\n=== 引用計數(shù)數(shù)學(xué)原理 ===")
        
        # 引用計數(shù)的基本公式
        formula = """
        引用計數(shù)變化公式：
        
        RC_{t+1} = RC_t + Δ_ref
        
        其中：
        - RC_t: 時間t時的引用計數(shù)
        - Δ_ref: 引用變化量
            Δ_ref = 新引用數(shù)量 - 消失引用數(shù)量
        
        對象釋放條件：
        RC_t = 0 ? 對象被立即釋放
        """
        print(formula)
        
        # 示例計算
        ref_count_history = [1, 2, 3, 2, 1, 0]  # 典型的引用計數(shù)變化
        lifetime = ReferenceCountingTheory.calculate_memory_lifetime(ref_count_history)
        
        print(f"示例引用計數(shù)歷史: {ref_count_history}")
        print(f"估算的對象生命周期: {lifetime:.2f}")

# 使用示例
if __name__ == "__main__":
    demo = ReferenceCountingDemo()
    demo.demonstrate_basic_reference_counting()
    demo.demonstrate_function_references()
    demo.analyze_reference_cycles()
    
    ReferenceCountingTheory.demonstrate_reference_counting_formula()

# reference_counting_analysis.py
from dataclasses import dataclass
from typing import List, Dict
import time

@dataclass
class ReferenceCountingMetrics:
    """引用計數(shù)性能指標(biāo)"""
    objects_created: int
    objects_destroyed: int
    memory_usage_mb: float
    collection_time_ms: float

class ReferenceCountingAnalysis:
    """引用計數(shù)機制深度分析"""
    
    def __init__(self):
        self.metrics_history: List[ReferenceCountingMetrics] = []
    
    def analyze_advantages(self):
        """分析引用計數(shù)的優(yōu)勢"""
        advantages = {
            "immediate_reclamation": {
                "description": "立即回收 - 引用計數(shù)為0時立即釋放內(nèi)存",
                "benefit": "減少內(nèi)存占用，提高內(nèi)存利用率",
                "example": "局部變量在函數(shù)結(jié)束時立即釋放"
            },
            "predictable_timing": {
                "description": "可預(yù)測的回收時機",
                "benefit": "避免Stop-the-World暫停",
                "example": "內(nèi)存釋放均勻分布在程序執(zhí)行過程中"
            },
            "low_latency": {
                "description": "低延遲 - 不需要復(fù)雜的垃圾回收周期",
                "benefit": "適合實時性要求高的應(yīng)用",
                "example": "GUI應(yīng)用、游戲等"
            },
            "cache_friendly": {
                "description": "緩存友好 - 對象在不再使用時立即釋放",
                "benefit": "提高緩存命中率",
                "example": "臨時對象不會長時間占用緩存"
            }
        }
        
        print("=== 引用計數(shù)優(yōu)勢分析 ===")
        for adv_key, adv_info in advantages.items():
            print(f"\n{adv_info['description']}:")
            print(f"  好處: {adv_info['benefit']}")
            print(f"  示例: {adv_info['example']}")
    
    def analyze_limitations(self):
        """分析引用計數(shù)的局限性"""
        limitations = {
            "circular_references": {
                "description": "循環(huán)引用問題 - 無法回收形成循環(huán)引用的對象",
                "impact": "內(nèi)存泄漏",
                "example": "兩個對象相互引用，但沒有外部引用"
            },
            "performance_overhead": {
                "description": "性能開銷 - 每次引用操作都需要更新計數(shù)",
                "impact": "降低程序執(zhí)行速度",
                "example": "函數(shù)調(diào)用、賦值操作都有額外開銷"
            },
            "memory_fragmentation": {
                "description": "內(nèi)存碎片 - 頻繁分配釋放導(dǎo)致內(nèi)存碎片",
                "impact": "降低內(nèi)存使用效率",
                "example": "大量小對象的創(chuàng)建和銷毀"
            },
            "atomic_operations": {
                "description": "原子操作開銷 - 多線程環(huán)境需要原子操作",
                "impact": "并發(fā)性能下降",
                "example": "多線程同時修改引用計數(shù)"
            }
        }
        
        print("\n=== 引用計數(shù)局限性分析 ===")
        for lim_key, lim_info in limitations.items():
            print(f"\n{lim_info['description']}:")
            print(f"  影響: {lim_info['impact']}")
            print(f"  示例: {lim_info['example']}")
    
    def performance_benchmark(self):
        """性能基準(zhǔn)測試"""
        print("\n=== 引用計數(shù)性能測試 ===")
        
        import gc
        gc.disable()  # 暫時禁用其他GC機制
        
        start_time = time.time()
        start_memory = self._get_memory_usage()
        
        # 創(chuàng)建大量臨時對象
        objects_created = 0
        for i in range(100000):
            # 創(chuàng)建臨時對象，依賴引用計數(shù)進行回收
            temp_list = [i for i in range(100)]
            temp_dict = {str(i): i for i in range(50)}
            objects_created += 2
            
            # 立即失去引用，應(yīng)該被立即回收
            del temp_list
            del temp_dict
        
        end_time = time.time()
        end_memory = self._get_memory_usage()
        
        gc.enable()
        
        execution_time = (end_time - start_time) * 1000  # 毫秒
        memory_used = end_memory - start_memory
        
        metrics = ReferenceCountingMetrics(
            objects_created=objects_created,
            objects_destroyed=objects_created,  # 理論上應(yīng)該全部被銷毀
            memory_usage_mb=memory_used,
            collection_time_ms=execution_time
        )
        
        self.metrics_history.append(metrics)
        
        print(f"創(chuàng)建對象數(shù)量: {metrics.objects_created}")
        print(f"執(zhí)行時間: {metrics.collection_time_ms:.2f} ms")
        print(f"內(nèi)存使用變化: {metrics.memory_usage_mb:.2f} MB")
        print(f"平均每個對象處理時間: {metrics.collection_time_ms/metrics.objects_created:.4f} ms")
    
    def _get_memory_usage(self):
        """獲取內(nèi)存使用量"""
        import psutil
        import os
        process = psutil.Process(os.getpid())
        return process.memory_info().rss / 1024 / 1024  # MB

# 循環(huán)引用問題深度分析
class CircularReferenceAnalyzer:
    """循環(huán)引用問題分析器"""
    
    def demonstrate_circular_reference_problem(self):
        """演示循環(huán)引用問題"""
        print("\n=== 循環(huán)引用問題演示 ===")
        
        class Person:
            def __init__(self, name):
                self.name = name
                self.friends = []
            
            def add_friend(self, friend):
                self.friends.append(friend)
                friend.friends.append(self)  # 相互引用
        
        # 創(chuàng)建循環(huán)引用
        alice = Person("Alice")
        bob = Person("Bob")
        
        print(f"創(chuàng)建Alice: {id(alice)}")
        print(f"創(chuàng)建Bob: {id(bob)}")
        
        # 形成循環(huán)引用
        alice.add_friend(bob)
        
        print("形成循環(huán)引用: Alice ? Bob")
        
        # 刪除外部引用
        del alice
        del bob
        
        print("刪除外部引用后，由于循環(huán)引用，對象無法被引用計數(shù)機制回收")
    
    def analyze_circular_reference_patterns(self):
        """分析常見的循環(huán)引用模式"""
        patterns = {
            "bidirectional_relationship": {
                "description": "雙向關(guān)系 - 兩個對象相互引用",
                "example": "父子節(jié)點相互引用",
                "solution": "使用弱引用(weakref)"
            },
            "self_reference": {
                "description": "自引用 - 對象引用自身",
                "example": "對象在屬性中引用自己",
                "solution": "避免自引用或使用弱引用"
            },
            "container_reference": {
                "description": "容器引用 - 對象被容器引用同時又引用容器",
                "example": "對象在列表中，同時又持有該列表的引用",
                "solution": "謹(jǐn)慎設(shè)計數(shù)據(jù)結(jié)構(gòu)"
            },
            "complex_cycle": {
                "description": "復(fù)雜循環(huán) - 多個對象形成引用環(huán)",
                "example": "A→B→C→A 的引用鏈",
                "solution": "需要分代垃圾回收來處理"
            }
        }
        
        print("\n=== 循環(huán)引用模式分析 ===")
        for pattern_key, pattern_info in patterns.items():
            print(f"\n{pattern_info['description']}:")
            print(f"  示例: {pattern_info['example']}")
            print(f"  解決方案: {pattern_info['solution']}")

# 使用示例
if __name__ == "__main__":
    analysis = ReferenceCountingAnalysis()
    analysis.analyze_advantages()
    analysis.analyze_limitations()
    analysis.performance_benchmark()
    
    circular_analyzer = CircularReferenceAnalyzer()
    circular_analyzer.demonstrate_circular_reference_problem()
    circular_analyzer.analyze_circular_reference_patterns()

# generational_gc.py
import gc
import time
from dataclasses import dataclass
from typing import List, Dict, Any
import weakref

@dataclass
class GenerationStats:
    """分代統(tǒng)計信息"""
    generation: int
    object_count: int
    collection_count: int
    last_collection_time: float

class GenerationalGCAnalyzer:
    """分代垃圾回收分析器"""
    
    def __init__(self):
        self.gc_stats = {}
        self.setup_gc_monitoring()
    
    def setup_gc_monitoring(self):
        """設(shè)置GC監(jiān)控"""
        # 啟用調(diào)試功能
        gc.set_debug(gc.DEBUG_STATS)
    
    def analyze_generations(self):
        """分析分代垃圾回收機制"""
        print("=== 分代垃圾回收分析 ===")
        
        # 獲取GC統(tǒng)計信息
        stats = gc.get_stats()
        
        print("\n分代假設(shè)原理:")
        print("1. 年輕代假設(shè): 大多數(shù)對象很快變得不可達")
        print("2. 老年代假設(shè): 存活時間越長的對象，越可能繼續(xù)存活")
        print("3. 代間提升: 存活足夠久的對象會被提升到老一代")
        
        print(f"\n當(dāng)前GC統(tǒng)計:")
        for gen_stats in stats:
            print(f"  第{gen_stats['generation']}代:")
            print(f"    回收次數(shù): {gen_stats['collected']}")
            print(f"    存活對象: {gen_stats['alive']}")
            print(f"    不可回收對象: {gen_stats['uncollectable']}")
    
    def demonstrate_generational_behavior(self):
        """演示分代行為"""
        print("\n=== 分代行為演示 ===")
        
        # 創(chuàng)建不同生命周期的對象
        short_lived_objects = self._create_short_lived_objects()
        long_lived_objects = self._create_long_lived_objects()
        
        print("創(chuàng)建短期存活對象和長期存活對象...")
        
        # 強制進行垃圾回收并觀察行為
        for generation in range(3):
            print(f"\n--- 強制第{generation}代GC ---")
            collected = gc.collect(generation)
            print(f"回收對象數(shù)量: {collected}")
            
            # 獲取當(dāng)前代統(tǒng)計
            current_stats = gc.get_count()
            print(f"當(dāng)前代計數(shù): {current_stats}")
    
    def _create_short_lived_objects(self) -> List[Any]:
        """創(chuàng)建短期存活對象"""
        objects = []
        for i in range(1000):
            # 創(chuàng)建對象但立即失去引用（模擬短期存活）
            temp = [j for j in range(10)]
            objects.append(temp)
        return objects[:100]  # 只保留少量引用
    
    def _create_long_lived_objects(self) -> List[Any]:
        """創(chuàng)建長期存活對象"""
        long_lived = []
        # 創(chuàng)建一些會長期存活的對象
        for i in range(100):
            obj = {"id": i, "data": "長期存活數(shù)據(jù)"}
            long_lived.append(obj)
        return long_lived
    
    def analyze_gc_thresholds(self):
        """分析GC觸發(fā)閾值"""
        print("\n=== GC觸發(fā)閾值分析 ===")
        
        # 獲取當(dāng)前GC閾值
        thresholds = gc.get_threshold()
        
        print("各代GC觸發(fā)閾值:")
        for i, threshold in enumerate(thresholds):
            print(f"  第{i}代: {threshold}")
        
        print("\n閾值含義:")
        print("  第0代: 當(dāng)分配的對象數(shù)量達到此閾值時，觸發(fā)第0代GC")
        print("  第1代: 當(dāng)?shù)?代GC執(zhí)行次數(shù)達到此閾值時，觸發(fā)第1代GC") 
        print("  第2代: 當(dāng)?shù)?代GC執(zhí)行次數(shù)達到此閾值時，觸發(fā)第2代GC")
        
        # 當(dāng)前對象計數(shù)
        current_count = gc.get_count()
        print(f"\n當(dāng)前對象計數(shù): {current_count}")
        print(f"距離下一次GC: {thresholds[0] - current_count[0]} 個對象")

class GCPerformanceAnalyzer:
    """GC性能分析器"""
    
    def __init__(self):
        self.performance_data = []
    
    def measure_gc_performance(self, object_count: int = 10000):
        """測量GC性能"""
        print(f"\n=== GC性能測試 ({object_count}個對象) ===")
        
        # 禁用GC進行基準(zhǔn)測試
        gc.disable()
        base_time = self._create_and_destroy_objects(object_count)
        
        # 啟用GC進行測試
        gc.enable()
        gc_time = self._create_and_destroy_objects(object_count)
        
        print(f"無GC時間: {base_time:.4f} 秒")
        print(f"有GC時間: {gc_time:.4f} 秒")
        print(f"GC開銷: {gc_time - base_time:.4f} 秒")
        print(f"相對開銷: {(gc_time - base_time) / base_time * 100:.2f}%")
    
    def _create_and_destroy_objects(self, count: int) -> float:
        """創(chuàng)建和銷毀對象并測量時間"""
        import time
        
        start_time = time.time()
        
        objects = []
        for i in range(count):
            # 創(chuàng)建復(fù)雜對象
            obj = {
                'id': i,
                'data': [j for j in range(10)],
                'nested': {'key': 'value' * (i % 10)}
            }
            objects.append(obj)
        
        # 模擬對象使用
        for obj in objects:
            _ = obj['id'] + len(obj['data'])
        
        # 銷毀對象（通過失去引用）
        del objects
        
        end_time = time.time()
        return end_time - start_time
    
    def analyze_memory_pressure_impact(self):
        """分析內(nèi)存壓力對GC的影響"""
        print("\n=== 內(nèi)存壓力對GC的影響 ===")
        
        memory_pressures = [1000, 5000, 10000, 50000]
        
        for pressure in memory_pressures:
            print(f"\n內(nèi)存壓力: {pressure} 個對象")
            
            # 測量不同內(nèi)存壓力下的GC性能
            start_time = time.time()
            
            # 創(chuàng)建內(nèi)存壓力
            large_objects = []
            for i in range(pressure):
                large_list = [j for j in range(100)]
                large_objects.append(large_list)
            
            # 執(zhí)行GC并測量時間
            gc_start = time.time()
            collected = gc.collect()
            gc_time = time.time() - gc_start
            
            # 清理
            del large_objects
            
            total_time = time.time() - start_time
            
            print(f"  GC回收對象: {collected}")
            print(f"  GC執(zhí)行時間: {gc_time:.4f} 秒")
            print(f"  總執(zhí)行時間: {total_time:.4f} 秒")

# 使用示例
if __name__ == "__main__":
    generational_analyzer = GenerationalGCAnalyzer()
    generational_analyzer.analyze_generations()
    generational_analyzer.demonstrate_generational_behavior()
    generational_analyzer.analyze_gc_thresholds()
    
    performance_analyzer = GCPerformanceAnalyzer()
    performance_analyzer.measure_gc_performance(5000)
    performance_analyzer.analyze_memory_pressure_impact()

# mark_sweep_algorithm.py
from typing import Set, List, Dict, Any
from enum import Enum
import time

class ObjectColor(Enum):
    """對象標(biāo)記顏色（三色標(biāo)記法）"""
    WHITE = 0  # 未訪問，可能垃圾
    GRAY = 1   # 正在處理，已訪問但引用未處理完
    BLACK = 2  # 已處理，存活對象

class GCNode:
    """垃圾回收節(jié)點（模擬對象）"""
    
    def __init__(self, obj_id: int, size: int = 1):
        self.obj_id = obj_id
        self.size = size
        self.references: List['GCNode'] = []
        self.color = ObjectColor.WHITE
        self.generation = 0
    
    def add_reference(self, node: 'GCNode'):
        """添加引用"""
        self.references.append(node)
    
    def __repr__(self):
        return f"GCNode({self.obj_id}, color={self.color.name}, gen={self.generation})"

class MarkSweepCollector:
    """標(biāo)記-清除垃圾回收器模擬"""
    
    def __init__(self):
        self.roots: Set[GCNode] = set()  # 根對象集合
        self.all_objects: Dict[int, GCNode] = {}  # 所有對象
        self.object_counter = 0
        
        # 統(tǒng)計信息
        self.stats = {
            'collections': 0,
            'objects_collected': 0,
            'memory_reclaimed': 0,
            'collection_times': []
        }
    
    def allocate_object(self, size: int = 1) -> GCNode:
        """分配新對象"""
        self.object_counter += 1
        obj = GCNode(self.object_counter, size)
        self.all_objects[obj.obj_id] = obj
        return obj
    
    def add_root(self, node: GCNode):
        """添加根對象"""
        self.roots.add(node)
    
    def mark_phase(self):
        """標(biāo)記階段 - 標(biāo)記所有從根對象可達的對象"""
        # 重置所有對象為白色
        for obj in self.all_objects.values():
            obj.color = ObjectColor.WHITE
        
        # 從根對象開始標(biāo)記
        gray_set: Set[GCNode] = set()
        
        # 根對象標(biāo)記為灰色
        for root in self.roots:
            root.color = ObjectColor.GRAY
            gray_set.add(root)
        
        # 處理灰色對象
        while gray_set:
            current = gray_set.pop()
            
            # 標(biāo)記當(dāng)前對象為黑色
            current.color = ObjectColor.BLACK
            
            # 處理所有引用
            for referenced in current.references:
                if referenced.color == ObjectColor.WHITE:
                    referenced.color = ObjectColor.GRAY
                    gray_set.add(referenced)
    
    def sweep_phase(self) -> List[GCNode]:
        """清除階段 - 回收所有白色對象"""
        collected_objects = []
        remaining_objects = {}
        
        for obj_id, obj in self.all_objects.items():
            if obj.color == ObjectColor.WHITE:
                # 白色對象是垃圾，進行回收
                collected_objects.append(obj)
                self.stats['objects_collected'] += 1
                self.stats['memory_reclaimed'] += obj.size
            else:
                # 黑色對象存活，保留并提升代際
                obj.generation = min(obj.generation + 1, 2)
                remaining_objects[obj_id] = obj
        
        self.all_objects = remaining_objects
        return collected_objects
    
    def collect_garbage(self) -> List[GCNode]:
        """執(zhí)行垃圾回收"""
        start_time = time.time()
        
        print("開始垃圾回收...")
        print(f"回收前對象數(shù)量: {len(self.all_objects)}")
        
        # 標(biāo)記階段
        self.mark_phase()
        
        # 清除階段
        collected = self.sweep_phase()
        
        # 更新統(tǒng)計
        self.stats['collections'] += 1
        collection_time = time.time() - start_time
        self.stats['collection_times'].append(collection_time)
        
        print(f"回收后對象數(shù)量: {len(self.all_objects)}")
        print(f"回收對象數(shù)量: {len(collected)}")
        print(f"回收時間: {collection_time:.4f} 秒")
        
        return collected
    
    def demonstrate_algorithm(self):
        """演示標(biāo)記-清除算法"""
        print("=== 標(biāo)記-清除算法演示 ===")
        
        # 創(chuàng)建對象圖
        root1 = self.allocate_object()
        root2 = self.allocate_object()
        
        obj3 = self.allocate_object()
        obj4 = self.allocate_object()
        obj5 = self.allocate_object()  # 這個對象將形成循環(huán)引用但不可達
        
        # 建立引用關(guān)系
        root1.add_reference(obj3)
        root2.add_reference(obj4)
        obj3.add_reference(obj4)
        
        # 創(chuàng)建循環(huán)引用但不可達的對象
        obj5.add_reference(obj5)  # 自引用
        
        # 設(shè)置根對象
        self.add_root(root1)
        self.add_root(root2)
        
        print("\n對象圖結(jié)構(gòu):")
        print(f"根對象: {root1.obj_id}, {root2.obj_id}")
        print(f"可達對象: {obj3.obj_id} ← root1, {obj4.obj_id} ← root2 & obj3")
        print(f"不可達對象: {obj5.obj_id} (自引用)")
        
        # 執(zhí)行垃圾回收
        collected = self.collect_garbage()
        
        print(f"\n回收的對象: {[obj.obj_id for obj in collected]}")
        
        # 顯示存活對象
        print(f"存活對象: {list(self.all_objects.keys())}")

class GenerationalCollector(MarkSweepCollector):
    """分代垃圾回收器"""
    
    def __init__(self):
        super().__init__()
        self.generations = [set(), set(), set()]  # 三代對象集合
        self.collection_thresholds = [700, 10, 10]  # 各代回收閾值
        self.allocation_count = 0
    
    def allocate_object(self, size: int = 1) -> GCNode:
        """分配對象到年輕代"""
        obj = super().allocate_object(size)
        self.generations[0].add(obj)
        self.allocation_count += 1
        
        # 檢查是否需要年輕代GC
        if self.allocation_count >= self.collection_thresholds[0]:
            self.collect_generation(0)
        
        return obj
    
    def collect_generation(self, generation: int):
        """回收指定代的對象"""
        print(f"\n--- 執(zhí)行第{generation}代GC ---")
        
        if generation == 0:
            # 年輕代GC：只處理第0代
            self._collect_young()
        else:
            # 老年代GC：處理指定代及所有更年輕的代
            self._collect_old(generation)
    
    def _collect_young(self):
        """年輕代回收"""
        # 臨時將年輕代對象作為根
        old_roots = self.roots.copy()
        self.roots.update(self.generations[1])  # 老年代對象作為根
        self.roots.update(self.generations[2])  # 老老年代對象作為根
        
        # 執(zhí)行標(biāo)記-清除
        collected = super().collect_garbage()
        
        # 提升存活對象到下一代
        self._promote_survivors()
        
        # 恢復(fù)根集合
        self.roots = old_roots
        
        # 重置分配計數(shù)
        self.allocation_count = 0
    
    def _promote_survivors(self):
        """提升存活對象到下一代"""
        promoted = set()
        for obj in self.generations[0]:
            if obj in self.all_objects.values():  # 對象仍然存活
                new_gen = min(obj.generation + 1, 2)
                self.generations[new_gen].add(obj)
                promoted.add(obj)
        
        # 從年輕代移除已提升的對象
        self.generations[0] = self.generations[0] - promoted
    
    def _collect_old(self, generation: int):
        """老年代回收"""
        # 收集指定代及所有更年輕的代
        for gen in range(generation + 1):
            # 將這些代的對象臨時作為根
            for g in range(gen + 1, 3):
                self.roots.update(self.generations[g])
        
        # 執(zhí)行標(biāo)記-清除
        collected = super().collect_garbage()
        
        # 重新組織分代
        self._reorganize_generations()

# 使用示例
if __name__ == "__main__":
    print("=== 標(biāo)記-清除算法演示 ===")
    basic_collector = MarkSweepCollector()
    basic_collector.demonstrate_algorithm()
    
    print("\n" + "="*50 + "\n")
    
    print("=== 分代垃圾回收演示 ===")
    gen_collector = GenerationalCollector()
    
    # 模擬對象分配模式
    for i in range(1000):
        obj = gen_collector.allocate_object()
        if i % 100 == 0:
            # 偶爾創(chuàng)建長期存活的對象
            gen_collector.add_root(obj)

# weak_references.py
import weakref
import gc
from typing import List, Dict, Any
from dataclasses import dataclass

class WeakReferenceDemo:
    """弱引用演示"""
    
    def demonstrate_basic_weakref(self):
        """演示基礎(chǔ)弱引用"""
        print("=== 基礎(chǔ)弱引用演示 ===")
        
        class Data:
            def __init__(self, value):
                self.value = value
                print(f"創(chuàng)建Data對象: {self.value}")
            
            def __del__(self):
                print(f"銷毀Data對象: {self.value}")
        
        # 創(chuàng)建普通引用
        data = Data("important_data")
        strong_ref = data
        
        # 創(chuàng)建弱引用
        weak_ref = weakref.ref(data)
        
        print(f"原始對象: {data}")
        print(f"強引用: {strong_ref}")
        print(f"弱引用: {weak_ref}")
        print(f"通過弱引用訪問: {weak_ref()}")
        
        # 刪除強引用
        del data
        del strong_ref
        
        # 強制垃圾回收
        gc.collect()
        
        print(f"回收后弱引用: {weak_ref()}")
    
    def demonstrate_weak_value_dictionary(self):
        """演示弱值字典"""
        print("\n=== 弱值字典演示 ===")
        
        # 創(chuàng)建弱值字典
        cache = weakref.WeakValueDictionary()
        
        class ExpensiveObject:
            def __init__(self, key):
                self.key = key
                self.data = "昂貴的計算結(jié)果"
                print(f"創(chuàng)建昂貴對象: {self.key}")
            
            def __del__(self):
                print(f"銷毀昂貴對象: {self.key}")
        
        # 向緩存添加對象
        obj1 = ExpensiveObject("key1")
        obj2 = ExpensiveObject("key2")
        
        cache["key1"] = obj1
        cache["key2"] = obj2
        
        print(f"緩存內(nèi)容: {list(cache.keys())}")
        print(f"獲取key1: {cache.get('key1')}")
        
        # 刪除對象的強引用
        del obj1
        gc.collect()
        
        print(f"回收后緩存內(nèi)容: {list(cache.keys())}")
        print(f"獲取key1: {cache.get('key1')}")
    
    def demonstrate_weak_set(self):
        """演示弱引用集合"""
        print("\n=== 弱引用集合演示 ===")
        
        observer_set = weakref.WeakSet()
        
        class Observer:
            def __init__(self, name):
                self.name = name
            
            def update(self):
                print(f"Observer {self.name} 收到更新")
            
            def __repr__(self):
                return f"Observer({self.name})"
        
        # 創(chuàng)建觀察者
        obs1 = Observer("A")
        obs2 = Observer("B")
        obs3 = Observer("C")
        
        # 添加到弱引用集合
        observer_set.add(obs1)
        observer_set.add(obs2)
        observer_set.add(obs3)
        
        print(f"觀察者集合: {list(observer_set)}")
        
        # 刪除一些觀察者
        del obs2
        gc.collect()
        
        print(f"回收后觀察者集合: {list(observer_set)}")
    
    def solve_circular_reference(self):
        """使用弱引用解決循環(huán)引用問題"""
        print("\n=== 使用弱引用解決循環(huán)引用 ===")
        
        class TreeNode:
            def __init__(self, value):
                self.value = value
                self._parent = None
                self.children = []
                print(f"創(chuàng)建節(jié)點: {self.value}")
            
            @property
            def parent(self):
                return self._parent() if self._parent else None
            
            @parent.setter
            def parent(self, node):
                if node is None:
                    self._parent = None
                else:
                    self._parent = weakref.ref(node)
            
            def add_child(self, child):
                self.children.append(child)
                child.parent = self
            
            def __del__(self):
                print(f"銷毀節(jié)點: {self.value}")
        
        # 創(chuàng)建樹結(jié)構(gòu)（可能產(chǎn)生循環(huán)引用）
        root = TreeNode("root")
        child1 = TreeNode("child1")
        child2 = TreeNode("child2")
        
        root.add_child(child1)
        root.add_child(child2)
        
        print(f"根節(jié)點的子節(jié)點: {[child.value for child in root.children]}")
        print(f"子節(jié)點1的父節(jié)點: {child1.parent.value if child1.parent else None}")
        
        # 刪除根節(jié)點引用
        del root
        gc.collect()
        
        print("注意：由于使用弱引用，循環(huán)引用被正確打破")

class CacheManager:
    """基于弱引用的緩存管理器"""
    
    def __init__(self, max_size: int = 100):
        self.cache = weakref.WeakValueDictionary()
        self.max_size = max_size
        self.access_count = 0
        self.hit_count = 0
    
    def get(self, key: Any) -> Any:
        """從緩存獲取值"""
        self.access_count += 1
        
        value = self.cache.get(key)
        if value is not None:
            self.hit_count += 1
        
        return value
    
    def set(self, key: Any, value: Any):
        """設(shè)置緩存值"""
        if len(self.cache) >= self.max_size:
            self._evict_oldest()
        
        self.cache[key] = value
    
    def _evict_oldest(self):
        """驅(qū)逐最老的緩存項"""
        # WeakValueDictionary會自動清理，這里只是演示
        print("緩存達到最大大小，等待自動清理...")
    
    def get_stats(self) -> Dict[str, Any]:
        """獲取緩存統(tǒng)計"""
        hit_rate = self.hit_count / self.access_count if self.access_count > 0 else 0
        
        return {
            'cache_size': len(self.cache),
            'access_count': self.access_count,
            'hit_count': self.hit_count,
            'hit_rate': hit_rate,
            'max_size': self.max_size
        }

# 使用示例
if __name__ == "__main__":
    demo = WeakReferenceDemo()
    demo.demonstrate_basic_weakref()
    demo.demonstrate_weak_value_dictionary()
    demo.demonstrate_weak_set()
    demo.solve_circular_reference()
    
    print("\n=== 緩存管理器演示 ===")
    cache = CacheManager(max_size=5)
    
    # 模擬緩存使用
    for i in range(10):
        key = f"key_{i}"
        value = f"value_{i}"
        cache.set(key, value)
        
        # 偶爾訪問之前的鍵
        if i % 3 == 0 and i > 0:
            cached_value = cache.get(f"key_{i-1}")
            print(f"訪問 key_{i-1}: {cached_value}")
    
    stats = cache.get_stats()
    print(f"\n緩存統(tǒng)計: {stats}")

# complete_gc_system.py
import gc
import time
from typing import Dict, List, Any
from dataclasses import dataclass
from enum import Enum
import threading

class GCStrategy(Enum):
    """垃圾回收策略"""
    REFERENCE_COUNTING = "reference_counting"
    GENERATIONAL_GC = "generational_gc"
    MANUAL_GC = "manual_gc"
    DISABLED_GC = "disabled_gc"

@dataclass
class GCProfile:
    """GC配置檔案"""
    name: str
    strategy: GCStrategy
    thresholds: tuple
    enabled: bool
    debug: bool

class CompleteGCSystem:
    """完整的垃圾回收系統(tǒng)"""
    
    def __init__(self):
        self.profiles: Dict[str, GCProfile] = {}
        self.current_profile: str = "balanced"
        self.performance_stats: Dict[str, List[float]] = {
            'collection_times': [],
            'memory_usage': [],
            'object_counts': []
        }
        
        self._setup_default_profiles()
    
    def _setup_default_profiles(self):
        """設(shè)置默認配置檔案"""
        self.profiles = {
            "performance": GCProfile(
                name="performance",
                strategy=GCStrategy.DISABLED_GC,
                thresholds=(0, 0, 0),
                enabled=False,
                debug=False
            ),
            "balanced": GCProfile(
                name="balanced", 
                strategy=GCStrategy.GENERATIONAL_GC,
                thresholds=(700, 10, 10),
                enabled=True,
                debug=False
            ),
            "aggressive": GCProfile(
                name="aggressive",
                strategy=GCStrategy.GENERATIONAL_GC, 
                thresholds=(300, 5, 5),
                enabled=True,
                debug=False
            ),
            "debug": GCProfile(
                name="debug",
                strategy=GCStrategy.GENERATIONAL_GC,
                thresholds=(100, 2, 2),
                enabled=True,
                debug=True
            )
        }
    
    def set_profile(self, profile_name: str):
        """設(shè)置GC配置"""
        if profile_name not in self.profiles:
            raise ValueError(f"未知的GC配置: {profile_name}")
        
        profile = self.profiles[profile_name]
        self.current_profile = profile_name
        
        # 應(yīng)用配置
        gc.set_threshold(*profile.thresholds)
        gc.enable() if profile.enabled else gc.disable()
        gc.set_debug(gc.DEBUG_STATS if profile.debug else 0)
        
        print(f"切換到GC配置: {profile_name}")
        print(f"  策略: {profile.strategy.value}")
        print(f"  閾值: {profile.thresholds}")
        print(f"  啟用: {profile.enabled}")
        print(f"  調(diào)試: {profile.debug}")
    
    def monitor_gc_performance(self, duration: int = 30):
        """監(jiān)控GC性能"""
        print(f"開始GC性能監(jiān)控 ({duration}秒)...")
        
        start_time = time.time()
        monitoring_thread = threading.Thread(
            target=self._monitoring_worker,
            args=(duration,)
        )
        monitoring_thread.daemon = True
        monitoring_thread.start()
        
        # 模擬工作負載
        self._generate_workload(duration)
        
        monitoring_thread.join()
        self._generate_performance_report()
    
    def _monitoring_worker(self, duration: int):
        """監(jiān)控工作線程"""
        end_time = time.time() + duration
        
        while time.time() < end_time:
            # 收集性能數(shù)據(jù)
            current_time = time.time()
            
            # 內(nèi)存使用
            memory_usage = self._get_memory_usage()
            
            # 對象計數(shù)
            object_count = len(gc.get_objects())
            
            # 記錄數(shù)據(jù)
            self.performance_stats['memory_usage'].append(memory_usage)
            self.performance_stats['object_counts'].append(object_count)
            
            time.sleep(1)  # 每秒采樣一次
    
    def _generate_workload(self, duration: int):
        """生成工作負載"""
        print("生成模擬工作負載...")
        
        end_time = time.time() + duration
        objects_created = 0
        
        while time.time() < end_time:
            # 創(chuàng)建各種對象模擬真實工作負載
            self._create_temporary_objects()
            self._create_long_lived_objects()
            self._create_circular_references()
            
            objects_created += 100
            time.sleep(0.1)  # 控制負載強度
        
        print(f"工作負載完成，創(chuàng)建了約 {objects_created} 個對象")
    
    def _create_temporary_objects(self):
        """創(chuàng)建臨時對象"""
        # 短期存活的對象
        for i in range(50):
            temp_list = [j for j in range(100)]
            temp_dict = {f"key_{j}": j for j in range(50)}
            # 對象會很快超出作用域并被回收
    
    def _create_long_lived_objects(self):
        """創(chuàng)建長期存活對象"""
        if not hasattr(self, 'long_lived_objects'):
            self.long_lived_objects = []
        
        # 一些長期存活的對象
        for i in range(10):
            persistent_obj = {"id": i, "data": "長期數(shù)據(jù)" * 100}
            self.long_lived_objects.append(persistent_obj)
    
    def _create_circular_references(self):
        """創(chuàng)建循環(huán)引用"""
        # 偶爾創(chuàng)建一些循環(huán)引用
        class Node:
            def __init__(self, id):
                self.id = id
                self.partner = None
        
        node1 = Node(1)
        node2 = Node(2)
        
        # 形成循環(huán)引用
        node1.partner = node2
        node2.partner = node1
        
        # 不保存引用，讓GC來處理
    
    def _get_memory_usage(self) -> float:
        """獲取內(nèi)存使用量"""
        import psutil
        import os
        process = psutil.Process(os.getpid())
        return process.memory_info().rss / 1024 / 1024  # MB
    
    def _generate_performance_report(self):
        """生成性能報告"""
        print("\n" + "="*50)
        print("GC性能報告")
        print("="*50)
        
        if not self.performance_stats['memory_usage']:
            print("沒有收集到性能數(shù)據(jù)")
            return
        
        # 內(nèi)存使用分析
        memory_data = self.performance_stats['memory_usage']
        avg_memory = sum(memory_data) / len(memory_data)
        max_memory = max(memory_data)
        min_memory = min(memory_data)
        
        print(f"內(nèi)存使用分析:")
        print(f"  平均: {avg_memory:.2f} MB")
        print(f"  最大: {max_memory:.2f} MB") 
        print(f"  最小: {min_memory:.2f} MB")
        print(f"  波動: {max_memory - min_memory:.2f} MB")
        
        # 對象數(shù)量分析
        object_data = self.performance_stats['object_counts']
        avg_objects = sum(object_data) / len(object_data)
        
        print(f"\n對象數(shù)量分析:")
        print(f"  平均對象數(shù): {avg_objects:.0f}")
        
        # GC統(tǒng)計
        gc_stats = gc.get_stats()
        print(f"\nGC統(tǒng)計:")
        for gen_stats in gc_stats:
            print(f"  第{gen_stats['generation']}代:")
            print(f"    回收次數(shù): {gen_stats['collected']}")
            print(f"    存活對象: {gen_stats['alive']}")

class MemoryOptimizer:
    """內(nèi)存優(yōu)化工具"""
    
    @staticmethod
    def optimize_memory_usage():
        """優(yōu)化內(nèi)存使用"""
        print("=== 內(nèi)存優(yōu)化建議 ===")
        
        suggestions = [
            "1. 使用生成器代替列表處理大數(shù)據(jù)集",
            "2. 及時刪除不再需要的大對象",
            "3. 使用__slots__減少對象內(nèi)存開銷", 
            "4. 避免不必要的對象創(chuàng)建",
            "5. 使用適當(dāng)?shù)臄?shù)據(jù)結(jié)構(gòu)",
            "6. 定期調(diào)用gc.collect()在關(guān)鍵點",
            "7. 使用弱引用打破循環(huán)引用",
            "8. 監(jiān)控內(nèi)存使用并設(shè)置警報"
        ]
        
        for suggestion in suggestions:
            print(suggestion)
    
    @staticmethod
    def demonstrate_memory_optimization():
        """演示內(nèi)存優(yōu)化技術(shù)"""
        print("\n=== 內(nèi)存優(yōu)化演示 ===")
        
        # 演示生成器的內(nèi)存優(yōu)勢
        print("1. 生成器 vs 列表:")
        
        # 列表方法（占用大量內(nèi)存）
        def get_numbers_list(n):
            return [i for i in range(n)]
        
        # 生成器方法（內(nèi)存高效）
        def get_numbers_generator(n):
            for i in range(n):
                yield i
        
        # 測試內(nèi)存使用
        import sys
        
        list_size = sys.getsizeof(get_numbers_list(1000000))
        gen_size = sys.getsizeof(get_numbers_generator(1000000))
        
        print(f"  列表大小: {list_size / 1024 / 1024:.2f} MB")
        print(f"  生成器大小: {gen_size} 字節(jié)")
        print(f"  內(nèi)存節(jié)省: {(list_size - gen_size) / list_size * 100:.1f}%")
        
        # 演示__slots__的內(nèi)存優(yōu)勢
        print("\n2. __slots__ 內(nèi)存優(yōu)化:")
        
        class RegularClass:
            def __init__(self, x, y):
                self.x = x
                self.y = y
        
        class SlotsClass:
            __slots__ = ['x', 'y']
            def __init__(self, x, y):
                self.x = x
                self.y = y
        
        regular_obj = RegularClass(1, 2)
        slots_obj = SlotsClass(1, 2)
        
        regular_size = sys.getsizeof(regular_obj) + sys.getsizeof(regular_obj.__dict__)
        slots_size = sys.getsizeof(slots_obj)
        
        print(f"  普通類大小: {regular_size} 字節(jié)")
        print(f"  slots類大小: {slots_size} 字節(jié)") 
        print(f"  內(nèi)存節(jié)省: {(regular_size - slots_size) / regular_size * 100:.1f}%")

# 使用示例
if __name__ == "__main__":
    # 完整GC系統(tǒng)演示
    gc_system = CompleteGCSystem()
    
    # 測試不同配置
    for profile_name in ["performance", "balanced", "aggressive"]:
        print(f"\n{'='*60}")
        print(f"測試配置: {profile_name}")
        print('='*60)
        
        gc_system.set_profile(profile_name)
        gc_system.monitor_gc_performance(duration=10)
    
    # 內(nèi)存優(yōu)化演示
    MemoryOptimizer.optimize_memory_usage()
    MemoryOptimizer.demonstrate_memory_optimization()