/* ダングリングポインタ: 解放後のメモリにアクセス */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char* create_greeting(const char* name) {
    char* buf = (char*)malloc(64);
    if (!buf) return NULL;
    snprintf(buf, 64, "Hello, %s!", name);
    return buf;
}
 
void dangerous_example(void) {
    char* msg = create_greeting("Alice");
    printf("%s\n", msg);   /* 正常 */
    free(msg);              /* 解放 */
 
    /* ダングリングポインタ: 未定義動作 */
    /* printf("%s\n", msg); */
 
    /* ダブルフリー: 致命的バグ */
    /* free(msg); */
}
 
/* メモリリーク: 解放し忘れ */
void leaky_function(void) {
    for (int i = 0; i < 1000000; i++) {
        char* buf = (char*)malloc(1024);
        /* buf を使う処理 ... */
        /* free(buf) を忘れている → 1GB のリーク */
    }
}

"""
参照カウントの詳細な観察 (Python 3.12+)
"""
import sys
import gc
 
# --- 基本的な参照カウントの増減 ---
class TrackedObject:
    """参照カウントを追跡するクラス"""
    _count = 0
 
    def __init__(self, name: str):
        TrackedObject._count += 1
        self.name = name
        self.id_num = TrackedObject._count
        print(f"  [CREATE] {self.name} (id={self.id_num})")
 
    def __del__(self):
        print(f"  [DELETE] {self.name} (id={self.id_num})")
 
def demonstrate_refcount():
    """参照カウントの増減を段階的に確認"""
    print("=== 参照カウント基本動作 ===\n")
 
    # Step 1: オブジェクト生成
    obj = TrackedObject("Alpha")
    base_count = sys.getrefcount(obj) - 1  # getrefcount自身の参照を除く
    print(f"  参照数: {base_count} (変数 obj のみ)\n")
 
    # Step 2: 別名を追加
    alias1 = obj
    print(f"  参照数: {sys.getrefcount(obj) - 1} (obj + alias1)\n")
 
    # Step 3: リストに格納
    container = [obj, obj, obj]
    print(f"  参照数: {sys.getrefcount(obj) - 1} (obj + alias1 + list*3)\n")
 
    # Step 4: リストから削除
    del container
    print(f"  参照数: {sys.getrefcount(obj) - 1} (obj + alias1)\n")
 
    # Step 5: 全参照を削除
    del alias1
    print(f"  参照数: {sys.getrefcount(obj) - 1} (obj のみ)\n")
 
    del obj
    print("  ↑ refcount=0 → __del__ が即座に呼ばれる\n")
 
def demonstrate_weak_reference():
    """弱参照は参照カウントを増加させないことを確認"""
    import weakref
 
    print("=== 弱参照と参照カウント ===\n")
 
    obj = TrackedObject("Beta")
    print(f"  強参照の数: {sys.getrefcount(obj) - 1}")
 
    # 弱参照を作成
    weak = weakref.ref(obj)
    print(f"  弱参照追加後: {sys.getrefcount(obj) - 1}  ← 変化なし!")
    print(f"  弱参照経由のアクセス: {weak().name}")
 
    # 強参照を削除
    del obj
    print(f"  強参照削除後: weak() = {weak()}  ← None になる\n")
 
if __name__ == "__main__":
    demonstrate_refcount()
    demonstrate_weak_reference()

// Swift ARC の動作を詳細に観察する例
import Foundation
 
// === 基本的な ARC の動作 ===
class Document {
    let title: String
    var author: Author?
 
    init(title: String) {
        self.title = title
        print("  Document '\(title)' を生成 (refcount=1)")
    }
 
    deinit {
        print("  Document '\(title)' を解放")
    }
}
 
class Author {
    let name: String
    // weak を使って循環参照を防止
    weak var primaryDocument: Document?
 
    init(name: String) {
        self.name = name
        print("  Author '\(name)' を生成")
    }
 
    deinit {
        print("  Author '\(name)' を解放")
    }
}
 
func arcDemo() {
    print("=== ARC 基本動作 ===")
 
    // refcount: doc=1
    var doc: Document? = Document(title: "GC Handbook")
 
    // refcount: author=1
    var author: Author? = Author(name: "Jones")
 
    // doc の author プロパティに代入 → author の refcount=2
    doc?.author = author
 
    // author の primaryDocument に代入 → weak なので doc の refcount は増えない
    author?.primaryDocument = doc
 
    print("\n  --- 参照を解放 ---")
 
    // author の refcount: 2 → 1 (doc.author がまだ保持)
    author = nil
    print("  author=nil 後: Author はまだ生存 (doc.author が保持)")
 
    // doc の refcount: 1 → 0 → 解放
    // doc 解放時に doc.author も解放 → author の refcount: 1 → 0 → 解放
    doc = nil
    print("  doc=nil 後: 連鎖的に両方解放された")
}
 
// === unowned の使用例 ===
class CreditCard {
    let number: String
    // unowned: nil にならないことが保証されている場合に使用
    unowned let owner: Customer
 
    init(number: String, owner: Customer) {
        self.number = number
        self.owner = owner
        print("  CreditCard \(number) を生成")
    }
 
    deinit {
        print("  CreditCard \(number) を解放")
    }
}
 
class Customer {
    let name: String
    var card: CreditCard?
 
    init(name: String) {
        self.name = name
        print("  Customer '\(name)' を生成")
    }
 
    deinit {
        print("  Customer '\(name)' を解放")
    }
}
 
func unownedDemo() {
    print("\n=== unowned の動作 ===")
 
    var customer: Customer? = Customer(name: "Alice")
    customer!.card = CreditCard(number: "1234-5678", owner: customer!)
 
    // customer を解放 → card も連鎖的に解放
    customer = nil
    // CreditCard.owner は unowned なので Customer の refcount を増やさない
    // Customer 解放 → Customer.card 解放 → CreditCard 解放
}
 
arcDemo()
unownedDemo()

// Rust: Rc<T> vs Arc<T> ─ 単一スレッド vs マルチスレッド参照カウント
use std::rc::Rc;
use std::sync::Arc;
use std::thread;
 
fn single_thread_rc() {
    // Rc<T>: 単一スレッド専用（アトミック操作なし → 高速）
    let a = Rc::new(vec![1, 2, 3]);
    println!("参照カウント: {}", Rc::strong_count(&a));  // 1
 
    let b = Rc::clone(&a);  // 非アトミックなインクリメント
    println!("参照カウント: {}", Rc::strong_count(&a));  // 2
 
    drop(b);
    println!("参照カウント: {}", Rc::strong_count(&a));  // 1
}
 
fn multi_thread_arc() {
    // Arc<T>: マルチスレッド対応（アトミック操作 → やや遅い）
    let data = Arc::new(vec![1, 2, 3, 4, 5]);
    let mut handles = vec![];
 
    for i in 0..4 {
        let data_clone = Arc::clone(&data);  // アトミックなインクリメント
        handles.push(thread::spawn(move || {
            println!("Thread {}: sum = {}", i, data_clone.iter().sum::<i32>());
            // スコープ終了時にアトミックなデクリメント
        }));
    }
 
    for handle in handles {
        handle.join().unwrap();
    }
    // 全スレッド終了後、data が唯一の参照 → refcount=1
    println!("最終参照カウント: {}", Arc::strong_count(&data));
}
 
fn main() {
    println!("=== 単一スレッド (Rc) ===");
    single_thread_rc();
 
    println!("\n=== マルチスレッド (Arc) ===");
    multi_thread_arc();
}

/**
 * Java GC の動作を観察するプログラム
 * 実行: java -verbose:gc -Xms64m -Xmx256m GCObservation
 */
import java.lang.ref.WeakReference;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.util.ArrayList;
import java.util.List;
 
public class GCObservation {
 
    // ファイナライザの実行タイミングを観察
    static class TrackedObject {
        private final String name;
        private final byte[] payload;  // メモリ消費用
 
        TrackedObject(String name, int sizeKB) {
            this.name = name;
            this.payload = new byte[sizeKB * 1024];
        }
 
        @Override
        protected void finalize() throws Throwable {
            System.out.printf("  [FINALIZE] %s (thread=%s)%n",
                name, Thread.currentThread().getName());
            super.finalize();
        }
    }
 
    public static void main(String[] args) throws Exception {
        System.out.println("=== トレーシングGC観察 (Java) ===\n");
 
        // --- 弱参照の動作 ---
        System.out.println("1. 弱参照の動作:");
        TrackedObject strong = new TrackedObject("Strong", 1);
        WeakReference<TrackedObject> weak =
            new WeakReference<>(new TrackedObject("WeakOnly", 1));
 
        System.out.printf("  GC前: weak.get() = %s%n",
            weak.get() != null ? "存在" : "null");
 
        System.gc();  // GC を要求（保証はされない）
        Thread.sleep(100);
 
        System.out.printf("  GC後: weak.get() = %s%n",
            weak.get() != null ? "存在" : "null");
 
        // --- メモリ圧迫による GC 発生 ---
        System.out.println("\n2. メモリ圧迫によるGC:");
        List<byte[]> pressure = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            pressure.add(new byte[1024 * 1024]);  // 1MB ずつ確保
            if (i % 20 == 0) {
                System.out.printf("  確保: %dMB%n", i + 1);
            }
        }
        pressure.clear();  // 参照を切る
        System.gc();
 
        // --- 循環参照の回収確認 ---
        System.out.println("\n3. 循環参照の回収:");
        TrackedObject nodeA = new TrackedObject("NodeA", 1);
        TrackedObject nodeB = new TrackedObject("NodeB", 1);
        // Java ではフィールドで循環を作る（簡略化のためリフレクション省略）
        // 重要: ルートからの参照を切れば循環していても回収される
        nodeA = null;
        nodeB = null;
        System.gc();
        Thread.sleep(200);
 
        System.out.println("\n=== 完了 ===");
    }
}

"""
循環参照の生成、検出、回収を詳細に観察する
"""
import gc
import sys
import weakref
 
class Node:
    """循環参照を作りやすいノードクラス"""
    _instances = 0
 
    def __init__(self, name: str):
        Node._instances += 1
        self.name = name
        self.neighbors: list = []
        print(f"  [+] Node '{name}' 生成 (総数: {Node._instances})")
 
    def __del__(self):
        Node._instances -= 1
        print(f"  [-] Node '{name}' 解放 (総数: {Node._instances})")
 
    def __repr__(self):
        return f"Node({self.name})"
 
def demo_circular_reference():
    """循環参照の生成と GC による回収"""
    print("=== 循環参照デモ ===\n")
 
    # GC を一時的に無効化して参照カウントのみの動作を観察
    gc.disable()
    print("1. GC無効状態で循環参照を作成:")
 
    a = Node("A")
    b = Node("B")
    a.neighbors.append(b)   # A → B
    b.neighbors.append(a)   # B → A  (循環!)
    print(f"   A の参照数: {sys.getrefcount(a) - 1}")
    print(f"   B の参照数: {sys.getrefcount(b) - 1}")
 
    # ローカル変数の参照を削除
    del a, b
    print("\n   del a, b 後: __del__ が呼ばれない! (循環参照リーク)")
    print(f"   未回収の Node 数: {Node._instances}")
 
    # GC を有効化して循環参照を回収
    print("\n2. GC を有効化して回収:")
    gc.enable()
    collected = gc.collect()
    print(f"   回収されたオブジェクト数: {collected}")
    print(f"   残りの Node 数: {Node._instances}")
 
def demo_weak_reference_solution():
    """弱参照による循環参照回避"""
    print("\n=== 弱参照による解決 ===\n")
 
    class SafeNode:
        def __init__(self, name: str):
            self.name = name
            self._neighbors_strong: list = []
            self._neighbors_weak: list = []
 
        def add_strong_ref(self, other):
            """強参照: 親 → 子"""
            self._neighbors_strong.append(other)
 
        def add_weak_ref(self, other):
            """弱参照: 子 → 親"""
            self._neighbors_weak.append(weakref.ref(other))
 
        def __del__(self):
            print(f"  [-] SafeNode '{self.name}' 解放")
 
    gc.disable()  # GC 無効でも回収されることを確認
 
    parent = SafeNode("Parent")
    child = SafeNode("Child")
 
    parent.add_strong_ref(child)   # 親 → 子: 強参照
    child.add_weak_ref(parent)     # 子 → 親: 弱参照
 
    del parent, child
    print("  del 後: 参照カウントだけで正しく回収された!")
 
    gc.enable()
 
if __name__ == "__main__":
    demo_circular_reference()
    demo_weak_reference_solution()

"""
Python GC の制御と監視 ── 実践的な使い方
"""
import gc
import sys
 
def inspect_gc_configuration():
    """GC の設定を確認"""
    print("=== Python GC 設定 ===\n")
 
    # 世代別 GC の閾値
    thresholds = gc.get_threshold()
    print(f"  世代別GC閾値: gen0={thresholds[0]}, "
          f"gen1={thresholds[1]}, gen2={thresholds[2]}")
    print(f"  意味: 世代0は {thresholds[0]} 回のアロケーション後にGC実行")
    print(f"        世代1は 世代0が {thresholds[1]} 回実行後にGC実行")
    print(f"        世代2は 世代1が {thresholds[2]} 回実行後にGC実行\n")
 
    # 現在の統計
    stats = gc.get_stats()
    for i, stat in enumerate(stats):
        print(f"  世代{i}: collections={stat['collections']}, "
              f"collected={stat['collected']}, "
              f"uncollectable={stat['uncollectable']}")
 
def demonstrate_gc_tuning():
    """性能チューニングの例"""
    print("\n=== GC チューニング ===\n")
 
    # 大量オブジェクト生成時は GC を一時停止
    print("  1. バッチ処理中の GC 一時停止:")
    gc.disable()
    objects = []
    for i in range(100000):
        objects.append({"index": i, "data": f"item_{i}"})
    gc.enable()
    gc.collect()
    print(f"     {len(objects)} オブジェクト生成完了\n")
 
    # 閾値調整
    print("  2. GC 閾値のカスタマイズ:")
    original = gc.get_threshold()
    print(f"     デフォルト: {original}")
 
    # レイテンシ重視: 頻繁に少量回収
    gc.set_threshold(100, 5, 5)
    print(f"     レイテンシ重視: {gc.get_threshold()}")
 
    # スループット重視: まれに大量回収
    gc.set_threshold(50000, 20, 20)
    print(f"     スループット重視: {gc.get_threshold()}")
 
    # デフォルトに戻す
    gc.set_threshold(*original)
    print(f"     復元: {gc.get_threshold()}")
 
def demonstrate_gc_callbacks():
    """GC コールバックによる監視"""
    print("\n=== GC コールバック監視 ===\n")
 
    def gc_callback(phase, info):
        if phase == "start":
            print(f"  [GC START] 世代{info['generation']}")
        elif phase == "stop":
            print(f"  [GC STOP]  回収={info['collected']}, "
                  f"回収不能={info['uncollectable']}")
 
    gc.callbacks.append(gc_callback)
 
    # 循環参照を作って GC を発動させる
    for _ in range(5):
        a, b = [], []
        a.append(b)
        b.append(a)
        del a, b
 
    gc.collect()
 
    gc.callbacks.remove(gc_callback)
 
if __name__ == "__main__":
    inspect_gc_configuration()
    demonstrate_gc_tuning()
    demonstrate_gc_callbacks()

// C# のメモリ管理: トレーシングGC + IDisposable
 
using System;
using System.Buffers;
using System.IO;
 
// === IDisposable パターン ===
// GC による非決定的回収 + using による決定的解放の組み合わせ
 
public class ManagedResource : IDisposable
{
    private FileStream? _stream;
    private byte[]? _buffer;
    private bool _disposed = false;
 
    public ManagedResource(string path)
    {
        _stream = new FileStream(path, FileMode.OpenOrCreate);
        _buffer = ArrayPool<byte>.Shared.Rent(4096);
        Console.WriteLine("  リソース確保: ファイル + バッファ");
    }
 
    // 決定的解放: using ブロック終了時に呼ばれる
    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);  // ファイナライザ不要を通知
    }
 
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
 
        if (disposing)
        {
            // マネージドリソースの解放
            _stream?.Dispose();
            if (_buffer != null)
            {
                ArrayPool<byte>.Shared.Return(_buffer);
                _buffer = null;
            }
            Console.WriteLine("  Dispose: マネージドリソース解放");
        }
 
        // アンマネージドリソースの解放（もしあれば）
        _disposed = true;
    }
 
    // 安全ネット: Dispose 忘れ時に GC が呼ぶ
    ~ManagedResource()
    {
        Console.WriteLine("  Finalizer: Dispose 忘れを検出!");
        Dispose(disposing: false);
    }
}
 
// === 使用例 ===
class Program
{
    static void Main()
    {
        Console.WriteLine("=== 決定的解放 (using) ===");
        // using ブロック: スコープ終了時に自動で Dispose()
        using (var resource = new ManagedResource("test.dat"))
        {
            // resource を使用...
        }  // ← ここで Dispose() が呼ばれる (GC を待たない)
 
        Console.WriteLine("\n=== C# 8.0 using 宣言 ===");
        // using 宣言: 変数のスコープ終了時に Dispose()
        using var resource2 = new ManagedResource("test2.dat");
        // resource2 を使用...
        // メソッド終了時に Dispose()
 
        Console.WriteLine("\n=== Span<T> によるゼロアロケーション ===");
        // GC を完全に回避するアプローチ
        Span<int> stackArray = stackalloc int[100];
        for (int i = 0; i < 100; i++)
            stackArray[i] = i * i;
        Console.WriteLine($"  スタック上の配列: [{stackArray[0]}, {stackArray[1]}, ...]");
    }
}

// Rust: 所有権 + 参照カウントのハイブリッド
use std::cell::RefCell;
use std::rc::{Rc, Weak};
 
// === 木構造: 所有権で十分 ===
#[derive(Debug)]
struct TreeNode {
    value: i32,
    children: Vec<TreeNode>,  // 親が子を所有
}
 
impl TreeNode {
    fn new(value: i32) -> Self {
        TreeNode { value, children: vec![] }
    }
 
    fn add_child(&mut self, child: TreeNode) {
        self.children.push(child);
    }
}
 
// === グラフ構造: Rc + Weak が必要 ===
#[derive(Debug)]
struct GraphNode {
    name: String,
    // 子への強参照
    children: RefCell<Vec<Rc<GraphNode>>>,
    // 親への弱参照（循環回避）
    parent: RefCell<Weak<GraphNode>>,
}
 
impl GraphNode {
    fn new(name: &str) -> Rc<Self> {
        Rc::new(GraphNode {
            name: name.to_string(),
            children: RefCell::new(vec![]),
            parent: RefCell::new(Weak::new()),
        })
    }
 
    fn add_child(parent: &Rc<GraphNode>, child: &Rc<GraphNode>) {
        // 親 → 子: 強参照
        parent.children.borrow_mut().push(Rc::clone(child));
        // 子 → 親: 弱参照
        *child.parent.borrow_mut() = Rc::downgrade(parent);
    }
}
 
impl Drop for GraphNode {
    fn drop(&mut self) {
        println!("  GraphNode '{}' を解放", self.name);
    }
}
 
fn main() {
    println!("=== 木構造 (所有権のみ) ===");
    {
        let mut root = TreeNode::new(1);
        let mut child1 = TreeNode::new(2);
        child1.add_child(TreeNode::new(4));
        child1.add_child(TreeNode::new(5));
        root.add_child(child1);
        root.add_child(TreeNode::new(3));
        println!("  {:?}", root);
    }  // root のスコープ終了 → 全ノードが自動解放（GC不要）
 
    println!("\n=== グラフ構造 (Rc + Weak) ===");
    {
        let parent = GraphNode::new("Parent");
        let child1 = GraphNode::new("Child1");
        let child2 = GraphNode::new("Child2");
 
        GraphNode::add_child(&parent, &child1);
        GraphNode::add_child(&parent, &child2);
 
        println!("  parent strong_count: {}", Rc::strong_count(&parent));
        println!("  child1 strong_count: {}", Rc::strong_count(&child1));
 
        // 子から親へのアクセス（弱参照経由）
        if let Some(p) = child1.parent.borrow().upgrade() {
            println!("  child1 の親: {}", p.name);
        }
    }  // スコープ終了 → Rc のカウントが 0 になり全て解放
    println!("  全ノード解放完了（循環参照なし）");
}

"""
アンチパターン: __del__ にリソース解放を依存する
 
問題点:
  1. 循環参照があると __del__ が呼ばれないことがある
  2. __del__ の実行順序は保証されない
  3. __del__ 内で例外が発生すると無視される
  4. インタプリタ終了時の __del__ の動作は未定義
"""
 
# NG: __del__ に依存したリソース管理
class BadDatabaseConnection:
    def __init__(self, dsn: str):
        self.conn = connect_to_database(dsn)  # 仮の関数
        self.is_open = True
 
    def __del__(self):
        # 危険: 循環参照があると呼ばれない可能性がある
        # 危険: インタプリタ終了時に connect_to_database が
        #       既に None になっている可能性がある
        if self.is_open:
            self.conn.close()
            self.is_open = False
 
# OK: コンテキストマネージャを使う
class GoodDatabaseConnection:
    def __init__(self, dsn: str):
        self.conn = connect_to_database(dsn)
        self.is_open = True
 
    def __enter__(self):
        return self
 
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()
        return False  # 例外は再送出
 
    def close(self):
        if self.is_open:
            self.conn.close()
            self.is_open = False
 
    def __del__(self):
        # 安全ネットとしてのみ使用
        if self.is_open:
            import warnings
            warnings.warn(
                f"GoodDatabaseConnection was not properly closed. "
                f"Use 'with' statement or call close() explicitly.",
                ResourceWarning,
                stacklevel=1
            )
            self.close()
 
# 正しい使い方:
# with GoodDatabaseConnection("postgresql://...") as db:
#     db.execute("SELECT ...")
# ← ここで確実に close() が呼ばれる

// アンチパターン: クロージャによる循環参照
 
import Foundation
 
// NG: クロージャが self を強参照でキャプチャ
class LeakyViewController {
    var name: String
    var onComplete: (() -> Void)?
 
    init(name: String) {
        self.name = name
        print("  [\(name)] init")
    }
 
    func setupCallback() {
        // 危険: self を暗黙的に強参照キャプチャ
        onComplete = {
            print("Completed: \(self.name)")  // self への強参照!
        }
        // 循環: self → onComplete → closure → self
    }
 
    deinit {
        print("  [\(name)] deinit")  // 呼ばれない!
    }
}
 
// OK: キャプチャリストで [weak self] を指定
class SafeViewController {
    var name: String
    var onComplete: (() -> Void)?
 
    init(name: String) {
        self.name = name
        print("  [\(name)] init")
    }
 
    func setupCallback() {
        // 安全: [weak self] でキャプチャ
        onComplete = { [weak self] in
            guard let self = self else {
                print("  既に解放済み")
                return
            }
            print("  Completed: \(self.name)")
        }
    }
 
    deinit {
        print("  [\(name)] deinit")  // 正しく呼ばれる
    }
}
 
// テスト
func testLeak() {
    print("=== リークするケース ===")
    var leaky: LeakyViewController? = LeakyViewController(name: "Leaky")
    leaky?.setupCallback()
    leaky = nil  // deinit が呼ばれない → リーク!
    print("  (deinit 未呼出 = メモリリーク)\n")
}
 
func testSafe() {
    print("=== 安全なケース ===")
    var safe: SafeViewController? = SafeViewController(name: "Safe")
    safe?.setupCallback()
    safe = nil  // deinit が正しく呼ばれる
}
 
testLeak()
testSafe()

/**
 * アンチパターン: コレクションに不要なオブジェクトを保持し続ける
 *
 * トレーシングGCでも、ルートから到達可能な限り回収されない。
 * GC は「不要なオブジェクト」ではなく「到達不能なオブジェクト」を回収する。
 */
import java.util.*;
import java.lang.ref.WeakReference;
 
public class MemoryLeakPatterns {
 
    // NG: 無限に成長するキャッシュ
    static class BadCache {
        private final Map<String, byte[]> cache = new HashMap<>();
 
        void put(String key, byte[] value) {
            cache.put(key, value);  // 際限なく追加される
            // GC は cache から到達可能なので回収しない
        }
    }
 
    // OK: WeakHashMap による自動回収キャッシュ
    static class GoodCache {
        // キーが GC されると対応するエントリも自動削除
        private final WeakHashMap<String, byte[]> cache = new WeakHashMap<>();
 
        void put(String key, byte[] value) {
            cache.put(key, value);
        }
    }
 
    // OK: サイズ制限付き LRU キャッシュ
    static class BoundedCache<K, V> extends LinkedHashMap<K, V> {
        private final int maxSize;
 
        BoundedCache(int maxSize) {
            super(maxSize, 0.75f, true);  // accessOrder=true
            this.maxSize = maxSize;
        }
 
        @Override
        protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
            return size() > maxSize;  // 上限超過で最古エントリを削除
        }
    }
}

"""
演習1: 参照カウントの手動追跡
 
各行の実行後に、X オブジェクトの参照カウントを答えよ。
sys.getrefcount() の「引数分の +1」は無視して純粋なカウントで回答すること。
"""
import sys
 
class X:
    pass
 
# Line 1
a = X()          # Q1: X の参照カウントは?
 
# Line 2
b = a            # Q2: X の参照カウントは?
 
# Line 3
c = [a, b, a]    # Q3: X の参照カウントは?
 
# Line 4
d = {"key": a}   # Q4: X の参照カウントは?
 
# Line 5
del c            # Q5: X の参照カウントは?
 
# Line 6
b = None         # Q6: X の参照カウントは?
 
# Line 7
d.clear()        # Q7: X の参照カウントは?
 
# Line 8
del a            # Q8: X の参照カウントは? X は解放されるか?

"""
演習2: 循環参照のメモリリークを修正する
 
以下の EventSystem クラスにはメモリリークがある。
原因を特定し、(A) 弱参照、(B) 明示的切断 の2つの方法で修正せよ。
"""
import gc
 
class EventEmitter:
    def __init__(self, name: str):
        self.name = name
        self.listeners = []
 
    def on(self, callback):
        self.listeners.append(callback)
 
    def emit(self, data):
        for listener in self.listeners:
            listener(data)
 
    def __del__(self):
        print(f"  EventEmitter '{self.name}' 解放")
 
class Widget:
    def __init__(self, widget_id: str):
        self.widget_id = widget_id
        self.emitter = EventEmitter(f"emitter-{widget_id}")
        # 問題: self.handle_event は self への強参照を含むバウンドメソッド
        self.emitter.on(self.handle_event)
 
    def handle_event(self, data):
        print(f"  Widget {self.widget_id} received: {data}")
 
    def __del__(self):
        print(f"  Widget '{self.widget_id}' 解放")
 
# テスト
gc.disable()
w = Widget("btn-1")
w.emitter.emit("click")
del w
print("  del w 後: Widget も EventEmitter も解放されない (リーク!)")
gc.enable()
gc.collect()
print("  gc.collect() 後: GC が循環参照を回収")

import weakref
 
class WidgetFixA:
    def __init__(self, widget_id: str):
        self.widget_id = widget_id
        self.emitter = EventEmitter(f"emitter-{widget_id}")
        # WeakMethod で弱参照のバウンドメソッドを登録
        weak_self = weakref.ref(self)
        def weak_handler(data, _ref=weak_self):
            obj = _ref()
            if obj is not None:
                obj.handle_event(data)
        self.emitter.on(weak_handler)
 
    def handle_event(self, data):
        print(f"  Widget {self.widget_id} received: {data}")
 
    def __del__(self):
        print(f"  WidgetFixA '{self.widget_id}' 解放")

class WidgetFixB:
    def __init__(self, widget_id: str):
        self.widget_id = widget_id
        self.emitter = EventEmitter(f"emitter-{widget_id}")
        self.emitter.on(self.handle_event)
 
    def handle_event(self, data):
        print(f"  Widget {self.widget_id} received: {data}")
 
    def destroy(self):
        """明示的にリスナーを切断してから参照を解除"""
        self.emitter.listeners.clear()
        self.emitter = None
 
    def __del__(self):
        print(f"  WidgetFixB '{self.widget_id}' 解放")
 
# 使い方:
# w = WidgetFixB("btn-1")
# w.destroy()  # 明示的切断
# del w        # 参照カウントで即座に回収

"""
演習3: 簡易参照カウント GC シミュレータの実装
 
以下のスケルトンを完成させよ。
要件:
  1. オブジェクトの生成と参照カウントの管理
  2. 参照の追加と削除
  3. 参照カウント == 0 での自動解放
  4. 循環参照の検出（ボーナス）
"""
from __future__ import annotations
from typing import Optional
 
class ManagedObject:
    """GC で管理されるオブジェクト"""
    _next_id = 0
 
    def __init__(self, name: str, gc: 'SimpleGC'):
        ManagedObject._next_id += 1
        self.id = ManagedObject._next_id
        self.name = name
        self.refcount = 0
        self.references: list[ManagedObject] = []
        self._gc = gc
        self._alive = True
 
    def add_reference(self, target: 'ManagedObject'):
        """target への参照を追加"""
        self.references.append(target)
        target.refcount += 1
        print(f"  {self.name} → {target.name}  "
              f"({target.name}.refcount = {target.refcount})")
 
    def remove_reference(self, target: 'ManagedObject'):
        """target への参照を削除"""
        if target in self.references:
            self.references.remove(target)
            target.refcount -= 1
            print(f"  {self.name} -/→ {target.name}  "
                  f"({target.name}.refcount = {target.refcount})")
            if target.refcount == 0:
                self._gc.free(target)
 
    def __repr__(self):
        refs = [r.name for r in self.references]
        return (f"Obj({self.name}, rc={self.refcount}, "
                f"refs={refs}, alive={self._alive})")
 
 
class SimpleGC:
    """簡易参照カウント GC"""
 
    def __init__(self):
        self.heap: list[ManagedObject] = []
        self.roots: dict[str, ManagedObject] = {}
 
    def allocate(self, name: str) -> ManagedObject:
        """新しいオブジェクトを割り当て"""
        obj = ManagedObject(name, self)
        self.heap.append(obj)
        print(f"  [ALLOC] {name} (heap size: {len(self.heap)})")
        return obj
 
    def add_root(self, var_name: str, obj: ManagedObject):
        """ルート変数を追加（参照カウント +1）"""
        if var_name in self.roots:
            old = self.roots[var_name]
            old.refcount -= 1
            if old.refcount == 0:
                self.free(old)
        self.roots[var_name] = obj
        obj.refcount += 1
        print(f"  [ROOT] {var_name} = {obj.name}  "
              f"({obj.name}.refcount = {obj.refcount})")
 
    def remove_root(self, var_name: str):
        """ルート変数を削除（参照カウント -1）"""
        if var_name in self.roots:
            obj = self.roots.pop(var_name)
            obj.refcount -= 1
            print(f"  [DEL]  {var_name}  "
                  f"({obj.name}.refcount = {obj.refcount})")
            if obj.refcount == 0:
                self.free(obj)
 
    def free(self, obj: ManagedObject):
        """オブジェクトを解放（参照先のカウントも減算）"""
        if not obj._alive:
            return
        obj._alive = False
        print(f"  [FREE] {obj.name}")
 
        # このオブジェクトが参照している先のカウントを減算
        for ref in obj.references[:]:
            ref.refcount -= 1
            print(f"    cascade: {ref.name}.refcount = {ref.refcount}")
            if ref.refcount == 0:
                self.free(ref)
 
        obj.references.clear()
        self.heap.remove(obj)
 
    def detect_cycles(self) -> list[set[str]]:
        """循環参照を検出（到達不能なオブジェクト群を返す）"""
        # ルートから到達可能なオブジェクトをマーク
        reachable = set()
 
        def mark(obj: ManagedObject):
            if obj.id in reachable:
                return
            reachable.add(obj.id)
            for ref in obj.references:
                if ref._alive:
                    mark(ref)
 
        for obj in self.roots.values():
            if obj._alive:
                mark(obj)
 
        # 到達不能なオブジェクトを検出
        unreachable = [obj for obj in self.heap
                       if obj.id not in reachable and obj._alive]
 
        if unreachable:
            names = {obj.name for obj in unreachable}
            print(f"  [CYCLE] 到達不能オブジェクト検出: {names}")
            return [names]
        return []
 
    def collect_cycles(self) -> int:
        """循環参照を強制回収"""
        cycles = self.detect_cycles()
        count = 0
        for cycle in cycles:
            for obj in self.heap[:]:
                if obj.name in cycle and obj._alive:
                    self.free(obj)
                    count += 1
        return count
 
    def status(self):
        """現在の状態を表示"""
        print(f"\n  --- GC Status ---")
        print(f"  Roots: {list(self.roots.keys())}")
        print(f"  Heap ({len(self.heap)} objects):")
        for obj in self.heap:
            print(f"    {obj}")
        print()
 
 
# === テスト実行 ===
def test_simple_gc():
    print("=== 簡易GCシミュレータ テスト ===\n")
 
    gc = SimpleGC()
 
    # 通常の参照カウント動作
    print("--- 1. 基本的な割り当てと解放 ---")
    a = gc.allocate("A")
    b = gc.allocate("B")
    gc.add_root("x", a)
    gc.add_root("y", b)
    a.add_reference(b)
    gc.status()
 
    gc.remove_root("x")  # A のカウントが 0 → A 解放 → B のカウント -1
    gc.status()
 
    gc.remove_root("y")  # B のカウントが 0 → B 解放
    gc.status()
 
    # 循環参照テスト
    print("--- 2. 循環参照の検出 ---")
    c = gc.allocate("C")
    d = gc.allocate("D")
    gc.add_root("z", c)
    c.add_reference(d)
    d.add_reference(c)  # 循環: C ↔ D
    gc.status()
 
    gc.remove_root("z")  # C.refcount=1 (D→C), D.refcount=1 (C→D) → リーク!
    gc.status()
 
    print("--- 3. 循環参照の回収 ---")
    collected = gc.collect_cycles()
    print(f"  回収数: {collected}")
    gc.status()
 
if __name__ == "__main__":
    test_simple_gc()