type SafeCounter struct {
    mu sync.Mutex
    v  map[string]int
}
 
func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.v[key]++
}
 
func (c *SafeCounter) Value(key string) int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.v[key]
}

type TTLCache struct {
    mu      sync.Mutex
    items   map[string]cacheItem
    ttl     time.Duration
    cleanCh chan struct{}
}
 
type cacheItem struct {
    value     interface{}
    expiresAt time.Time
}
 
func NewTTLCache(ttl time.Duration) *TTLCache {
    c := &TTLCache{
        items:   make(map[string]cacheItem),
        ttl:     ttl,
        cleanCh: make(chan struct{}),
    }
    go c.cleanup()
    return c
}
 
func (c *TTLCache) Set(key string, value interface{}) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = cacheItem{
        value:     value,
        expiresAt: time.Now().Add(c.ttl),
    }
}
 
func (c *TTLCache) Get(key string) (interface{}, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()
 
    item, ok := c.items[key]
    if !ok {
        return nil, false
    }
    if time.Now().After(item.expiresAt) {
        delete(c.items, key)
        return nil, false
    }
    return item.value, true
}
 
func (c *TTLCache) Delete(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.items, key)
}
 
func (c *TTLCache) Len() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return len(c.items)
}
 
func (c *TTLCache) cleanup() {
    ticker := time.NewTicker(c.ttl / 2)
    defer ticker.Stop()
 
    for {
        select {
        case <-ticker.C:
            c.mu.Lock()
            now := time.Now()
            for key, item := range c.items {
                if now.After(item.expiresAt) {
                    delete(c.items, key)
                }
            }
            c.mu.Unlock()
        case <-c.cleanCh:
            return
        }
    }
}
 
func (c *TTLCache) Close() {
    close(c.cleanCh)
}

type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}
 
func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock()         // 読み取りロック（複数同時可）
    defer c.mu.RUnlock()
    v, ok := c.data[key]
    return v, ok
}
 
func (c *Cache) Set(key, value string) {
    c.mu.Lock()          // 書き込みロック（排他）
    defer c.mu.Unlock()
    c.data[key] = value
}

// RWMutex の読み取り/書き込みの動作
//
// 読み取りロック (RLock):
//   - 書き込みロックが保持されていなければ即座に取得
//   - 複数の goroutine が同時に RLock を保持可能
//   - 書き込みロックが待機中の場合、新しい RLock は待機する
//     （書き込み側の飢餓を防ぐ）
//
// 書き込みロック (Lock):
//   - 全ての RLock が解放されるまで待機
//   - 取得後は他の RLock も Lock も取得不可
 
type ConfigManager struct {
    mu     sync.RWMutex
    config map[string]string
}
 
func NewConfigManager() *ConfigManager {
    return &ConfigManager{
        config: make(map[string]string),
    }
}
 
// 読み取りは複数同時可能
func (cm *ConfigManager) Get(key string) string {
    cm.mu.RLock()
    defer cm.mu.RUnlock()
    return cm.config[key]
}
 
// GetAll は設定のスナップショットを返す
func (cm *ConfigManager) GetAll() map[string]string {
    cm.mu.RLock()
    defer cm.mu.RUnlock()
 
    // コピーを返す（ロック外での変更を防ぐ）
    snapshot := make(map[string]string, len(cm.config))
    for k, v := range cm.config {
        snapshot[k] = v
    }
    return snapshot
}
 
// 書き込みは排他
func (cm *ConfigManager) Set(key, value string) {
    cm.mu.Lock()
    defer cm.mu.Unlock()
    cm.config[key] = value
}
 
// バルク更新（トランザクション的な更新）
func (cm *ConfigManager) Update(updates map[string]string) {
    cm.mu.Lock()
    defer cm.mu.Unlock()
 
    for k, v := range updates {
        cm.config[k] = v
    }
}

// ベンチマークで読み取り割合による性能差を測定
func BenchmarkMutexRead(b *testing.B) {
    var mu sync.Mutex
    data := map[string]int{"key": 42}
 
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            mu.Lock()
            _ = data["key"]
            mu.Unlock()
        }
    })
}
 
func BenchmarkRWMutexRead(b *testing.B) {
    var mu sync.RWMutex
    data := map[string]int{"key": 42}
 
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            mu.RLock()
            _ = data["key"]
            mu.RUnlock()
        }
    })
}
 
// 結果の目安（8コアマシン）:
// BenchmarkMutexRead-8      20000000    60 ns/op
// BenchmarkRWMutexRead-8    50000000    25 ns/op
//
// → 読み取りが95%以上の場合、RWMutexが有利
// → 書き込みが50%以上の場合、Mutexの方が良いことがある
//   （RWMutexのオーバーヘッドのため）

var (
    instance *Database
    once     sync.Once
)
 
func GetDB() *Database {
    once.Do(func() {
        // 複数goroutineから呼ばれても1度だけ実行
        instance = &Database{
            conn: connectDB(),
        }
    })
    return instance
}

// Go 1.21 で追加された便利なヘルパー
 
// sync.OnceFunc: 関数を1回だけ実行するラッパーを返す
cleanup := sync.OnceFunc(func() {
    fmt.Println("クリーンアップ実行")
    db.Close()
})
 
cleanup() // "クリーンアップ実行" が出力
cleanup() // 何も起きない（2回目は実行されない）
 
// sync.OnceValue: 値を1回だけ計算するラッパーを返す
getConfig := sync.OnceValue(func() *Config {
    fmt.Println("設定読み込み中...")
    cfg, err := loadConfig("config.yaml")
    if err != nil {
        panic(err) // panicは再呼び出し時にも再送出される
    }
    return cfg
})
 
cfg := getConfig() // "設定読み込み中..." が出力
cfg = getConfig()  // キャッシュされた値を返す
 
// sync.OnceValues: 値とエラーを返す版
loadCert := sync.OnceValues(func() (*tls.Certificate, error) {
    return tls.LoadX509KeyPair("cert.pem", "key.pem")
})
 
cert, err := loadCert() // 初回: ファイルを読み込む
cert, err = loadCert()  // 2回目: キャッシュされた結果を返す

// sync.Once で初期化エラーを安全に扱うパターン
type LazyDB struct {
    once sync.Once
    db   *sql.DB
    err  error
}
 
func (l *LazyDB) Get() (*sql.DB, error) {
    l.once.Do(func() {
        l.db, l.err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
        if l.err != nil {
            return
        }
        l.err = l.db.Ping()
    })
    return l.db, l.err
}
 
// 注意: Once.Do は panic しても「完了」とみなす
// エラーの場合はリトライしたければ別のアプローチが必要
 
// リトライ可能な初期化（sync.Once は使えない）
type RetryableInit struct {
    mu       sync.Mutex
    db       *sql.DB
    initDone bool
}
 
func (r *RetryableInit) Get() (*sql.DB, error) {
    r.mu.Lock()
    defer r.mu.Unlock()
 
    if r.initDone {
        return r.db, nil
    }
 
    db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        return nil, err // 次回の呼び出しで再試行可能
    }
 
    if err := db.Ping(); err != nil {
        db.Close()
        return nil, err // 次回の呼び出しで再試行可能
    }
 
    r.db = db
    r.initDone = true
    return r.db, nil
}

var bufPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}
 
func processRequest(data []byte) string {
    buf := bufPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufPool.Put(buf) // プールに返却
    }()
 
    buf.Write(data)
    return buf.String()
}

// JSON エンコーダのプール
var encoderPool = sync.Pool{
    New: func() interface{} {
        return &bytes.Buffer{}
    },
}
 
func respondJSON(w http.ResponseWriter, data interface{}) error {
    buf := encoderPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        encoderPool.Put(buf)
    }()
 
    if err := json.NewEncoder(buf).Encode(data); err != nil {
        return err
    }
 
    w.Header().Set("Content-Type", "application/json")
    _, err := w.Write(buf.Bytes())
    return err
}
 
// スライスのプール（固定サイズバッファ）
var slicePool = sync.Pool{
    New: func() interface{} {
        s := make([]byte, 0, 4096)
        return &s
    },
}
 
func processData(input []byte) []byte {
    bufPtr := slicePool.Get().(*[]byte)
    buf := (*bufPtr)[:0] // 長さをリセット、容量は保持
    defer func() {
        *bufPtr = buf[:0]
        slicePool.Put(bufPtr)
    }()
 
    // buf を使って処理
    buf = append(buf, input...)
    // ... 処理 ...
 
    // 結果をコピーして返す（プール外に持ち出す場合はコピー必須）
    result := make([]byte, len(buf))
    copy(result, buf)
    return result
}
 
// sync.Pool を使ったログフォーマッタ
type LogFormatter struct {
    pool sync.Pool
}
 
func NewLogFormatter() *LogFormatter {
    return &LogFormatter{
        pool: sync.Pool{
            New: func() interface{} {
                return &strings.Builder{}
            },
        },
    }
}
 
func (f *LogFormatter) Format(level, msg string, fields map[string]interface{}) string {
    sb := f.pool.Get().(*strings.Builder)
    defer func() {
        sb.Reset()
        f.pool.Put(sb)
    }()
 
    sb.WriteString(time.Now().Format(time.RFC3339))
    sb.WriteString(" [")
    sb.WriteString(level)
    sb.WriteString("] ")
    sb.WriteString(msg)
 
    for k, v := range fields {
        sb.WriteString(" ")
        sb.WriteString(k)
        sb.WriteString("=")
        fmt.Fprintf(sb, "%v", v)
    }
 
    return sb.String()
}

type AtomicCounter struct {
    count atomic.Int64  // Go 1.19+
}
 
func (c *AtomicCounter) Inc() {
    c.count.Add(1)
}
 
func (c *AtomicCounter) Value() int64 {
    return c.count.Load()
}
 
// atomic.Value で任意の値を安全に読み書き
var config atomic.Value // *Config
 
func UpdateConfig(cfg *Config) {
    config.Store(cfg)
}
 
func GetConfig() *Config {
    return config.Load().(*Config)
}

// Go 1.19+ の型安全な atomic 型
type Metrics struct {
    RequestCount  atomic.Int64
    ErrorCount    atomic.Int64
    ActiveConns   atomic.Int32
    BytesReceived atomic.Uint64
    IsHealthy     atomic.Bool
}
 
func (m *Metrics) RecordRequest(success bool, bytes uint64) {
    m.RequestCount.Add(1)
    m.BytesReceived.Add(bytes)
    if !success {
        m.ErrorCount.Add(1)
    }
}
 
func (m *Metrics) ConnectionOpened() {
    m.ActiveConns.Add(1)
}
 
func (m *Metrics) ConnectionClosed() {
    m.ActiveConns.Add(-1)
}
 
func (m *Metrics) Snapshot() map[string]interface{} {
    return map[string]interface{}{
        "requests":       m.RequestCount.Load(),
        "errors":         m.ErrorCount.Load(),
        "active_conns":   m.ActiveConns.Load(),
        "bytes_received": m.BytesReceived.Load(),
        "healthy":        m.IsHealthy.Load(),
    }
}

// CAS を使ったロックフリーなスタック
type LockFreeStack struct {
    top atomic.Pointer[node]
}
 
type node struct {
    value int
    next  *node
}
 
func (s *LockFreeStack) Push(value int) {
    newNode := &node{value: value}
    for {
        oldTop := s.top.Load()
        newNode.next = oldTop
        // CAS: top が oldTop のままなら newNode に置き換え
        if s.top.CompareAndSwap(oldTop, newNode) {
            return
        }
        // 失敗した場合はリトライ（他の goroutine が先に変更した）
    }
}
 
func (s *LockFreeStack) Pop() (int, bool) {
    for {
        oldTop := s.top.Load()
        if oldTop == nil {
            return 0, false
        }
        // CAS: top が oldTop のままなら next に置き換え
        if s.top.CompareAndSwap(oldTop, oldTop.next) {
            return oldTop.value, true
        }
        // 失敗した場合はリトライ
    }
}
 
// atomic.Value による設定のホットリロード
type HotConfig struct {
    value atomic.Value
}
 
func NewHotConfig(initial *AppConfig) *HotConfig {
    hc := &HotConfig{}
    hc.value.Store(initial)
    return hc
}
 
func (hc *HotConfig) Get() *AppConfig {
    return hc.value.Load().(*AppConfig)
}
 
func (hc *HotConfig) Reload(newConfig *AppConfig) {
    hc.value.Store(newConfig)
    // 読み取り側は次の Load() で新しい設定を取得
    // ロック不要、読み取りは常にノンブロッキング
}
 
// ファイル監視と組み合わせたホットリロード
func (hc *HotConfig) WatchFile(ctx context.Context, path string) error {
    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()
 
    var lastModified time.Time
 
    for {
        select {
        case <-ticker.C:
            info, err := os.Stat(path)
            if err != nil {
                log.Printf("設定ファイル確認エラー: %v", err)
                continue
            }
 
            if info.ModTime().After(lastModified) {
                cfg, err := loadAppConfig(path)
                if err != nil {
                    log.Printf("設定読み込みエラー: %v", err)
                    continue
                }
                hc.Reload(cfg)
                lastModified = info.ModTime()
                log.Printf("設定リロード完了: %s", path)
            }
 
        case <-ctx.Done():
            return ctx.Err()
        }
    }
}

var cache sync.Map
 
func main() {
    // Store
    cache.Store("key1", "value1")
    cache.Store("key2", "value2")
 
    // Load
    if v, ok := cache.Load("key1"); ok {
        fmt.Println(v.(string))
    }
 
    // LoadOrStore: 既存なら取得、なければ格納
    actual, loaded := cache.LoadOrStore("key3", "value3")
    fmt.Println(actual, loaded) // "value3" false
 
    // Range: 全要素を走査
    cache.Range(func(key, value any) bool {
        fmt.Printf("%s: %s\n", key, value)
        return true // falseで中断
    })
}

// sync.Map が適するケース:
//
// 1. キーが安定している（追加はあるが削除は少ない）
// 2. 読み取りが圧倒的に多い
// 3. キーごとにアクセスするgoroutineが異なる（キーの分散）
 
// ケース1: ルーティングテーブル（起動時に設定、ランタイムで読み取り）
var routeHandlers sync.Map
 
func registerRoute(pattern string, handler http.Handler) {
    routeHandlers.Store(pattern, handler)
}
 
func findHandler(pattern string) (http.Handler, bool) {
    v, ok := routeHandlers.Load(pattern)
    if !ok {
        return nil, false
    }
    return v.(http.Handler), true
}
 
// ケース2: goroutine-local なストレージ
var goroutineData sync.Map
 
func processWithID(id int) {
    goroutineData.Store(id, &ProcessState{
        StartTime: time.Now(),
    })
    defer goroutineData.Delete(id)
 
    // 処理...
}
 
// sync.Map が適さないケース → map + RWMutex を使う
//
// 1. 頻繁な書き込みがある
// 2. 全要素の走査（Range）が頻繁
// 3. 型安全性が必要
 
// 型安全な汎用マップ（ジェネリクス + RWMutex）
type SafeMap[K comparable, V any] struct {
    mu   sync.RWMutex
    data map[K]V
}
 
func NewSafeMap[K comparable, V any]() *SafeMap[K, V] {
    return &SafeMap[K, V]{
        data: make(map[K]V),
    }
}
 
func (m *SafeMap[K, V]) Get(key K) (V, bool) {
    m.mu.RLock()
    defer m.mu.RUnlock()
    v, ok := m.data[key]
    return v, ok
}
 
func (m *SafeMap[K, V]) Set(key K, value V) {
    m.mu.Lock()
    defer m.mu.Unlock()
    m.data[key] = value
}
 
func (m *SafeMap[K, V]) Delete(key K) {
    m.mu.Lock()
    defer m.mu.Unlock()
    delete(m.data, key)
}
 
func (m *SafeMap[K, V]) Len() int {
    m.mu.RLock()
    defer m.mu.RUnlock()
    return len(m.data)
}
 
func (m *SafeMap[K, V]) Range(fn func(K, V) bool) {
    m.mu.RLock()
    defer m.mu.RUnlock()
    for k, v := range m.data {
        if !fn(k, v) {
            break
        }
    }
}

// sync.Cond は条件が満たされるまで goroutine を待機させる
// チャネルでは実現しにくい「ブロードキャスト通知」が可能
 
type BoundedQueue struct {
    mu       sync.Mutex
    notEmpty *sync.Cond
    notFull  *sync.Cond
    items    []interface{}
    maxSize  int
}
 
func NewBoundedQueue(maxSize int) *BoundedQueue {
    q := &BoundedQueue{
        items:   make([]interface{}, 0, maxSize),
        maxSize: maxSize,
    }
    q.notEmpty = sync.NewCond(&q.mu)
    q.notFull = sync.NewCond(&q.mu)
    return q
}
 
func (q *BoundedQueue) Put(item interface{}) {
    q.mu.Lock()
    defer q.mu.Unlock()
 
    // キューが満杯の間は待機
    for len(q.items) >= q.maxSize {
        q.notFull.Wait() // mu.Unlock() → 待機 → mu.Lock()
    }
 
    q.items = append(q.items, item)
    q.notEmpty.Signal() // 1つの待機goroutineを起こす
}
 
func (q *BoundedQueue) Take() interface{} {
    q.mu.Lock()
    defer q.mu.Unlock()
 
    // キューが空の間は待機
    for len(q.items) == 0 {
        q.notEmpty.Wait()
    }
 
    item := q.items[0]
    q.items = q.items[1:]
    q.notFull.Signal()
    return item
}
 
// Broadcast の使用例: 全待機者への通知
type ReadyGate struct {
    mu    sync.Mutex
    cond  *sync.Cond
    ready bool
}
 
func NewReadyGate() *ReadyGate {
    g := &ReadyGate{}
    g.cond = sync.NewCond(&g.mu)
    return g
}
 
func (g *ReadyGate) Wait() {
    g.mu.Lock()
    defer g.mu.Unlock()
    for !g.ready {
        g.cond.Wait()
    }
}
 
func (g *ReadyGate) Open() {
    g.mu.Lock()
    defer g.mu.Unlock()
    g.ready = true
    g.cond.Broadcast() // 全ての待機 goroutine を起こす
}
 
// 使用例
func main() {
    gate := NewReadyGate()
 
    // 複数のワーカーがゲートの開放を待つ
    for i := 0; i < 10; i++ {
        go func(id int) {
            gate.Wait()
            fmt.Printf("Worker %d: started\n", id)
        }(i)
    }
 
    time.Sleep(time.Second)
    fmt.Println("Opening gate...")
    gate.Open() // 全ワーカーが一斉に開始
}

// WaitGroup + セマフォ: 同時実行数制限付き並行処理
func processWithLimit(items []Item, maxConcurrency int) error {
    var wg sync.WaitGroup
    sem := make(chan struct{}, maxConcurrency)
    errCh := make(chan error, len(items))
 
    for _, item := range items {
        wg.Add(1)
        go func(it Item) {
            defer wg.Done()
 
            sem <- struct{}{}        // セマフォ取得
            defer func() { <-sem }() // セマフォ解放
 
            if err := process(it); err != nil {
                errCh <- err
            }
        }(item)
    }
 
    wg.Wait()
    close(errCh)
 
    // エラーの集約
    var errs []error
    for err := range errCh {
        errs = append(errs, err)
    }
    if len(errs) > 0 {
        return fmt.Errorf("処理エラー %d件: %v", len(errs), errs[0])
    }
    return nil
}
 
// WaitGroup + 進捗報告
type ProgressTracker struct {
    total     int
    completed atomic.Int64
    wg        sync.WaitGroup
}
 
func NewProgressTracker(total int) *ProgressTracker {
    pt := &ProgressTracker{total: total}
    pt.wg.Add(total)
    return pt
}
 
func (pt *ProgressTracker) Done() {
    pt.completed.Add(1)
    pt.wg.Done()
}
 
func (pt *ProgressTracker) Wait() {
    pt.wg.Wait()
}
 
func (pt *ProgressTracker) Progress() float64 {
    return float64(pt.completed.Load()) / float64(pt.total) * 100
}
 
// 使用例
func processFiles(files []string) {
    pt := NewProgressTracker(len(files))
 
    // 進捗報告 goroutine
    go func() {
        ticker := time.NewTicker(time.Second)
        defer ticker.Stop()
        for {
            select {
            case <-ticker.C:
                fmt.Printf("進捗: %.1f%%\n", pt.Progress())
                if pt.Progress() >= 100 {
                    return
                }
            }
        }
    }()
 
    for _, file := range files {
        go func(f string) {
            defer pt.Done()
            processFile(f)
        }(file)
    }
 
    pt.Wait()
    fmt.Println("全ファイル処理完了")
}

// 大量のキーを持つ並行マップの性能を向上させるシャーディング
const numShards = 32
 
type ShardedMap[V any] struct {
    shards [numShards]struct {
        mu    sync.RWMutex
        items map[string]V
    }
}
 
func NewShardedMap[V any]() *ShardedMap[V] {
    sm := &ShardedMap[V]{}
    for i := range sm.shards {
        sm.shards[i].items = make(map[string]V)
    }
    return sm
}
 
func (sm *ShardedMap[V]) shard(key string) int {
    h := fnv.New32a()
    h.Write([]byte(key))
    return int(h.Sum32()) % numShards
}
 
func (sm *ShardedMap[V]) Get(key string) (V, bool) {
    s := &sm.shards[sm.shard(key)]
    s.mu.RLock()
    defer s.mu.RUnlock()
    v, ok := s.items[key]
    return v, ok
}
 
func (sm *ShardedMap[V]) Set(key string, value V) {
    s := &sm.shards[sm.shard(key)]
    s.mu.Lock()
    defer s.mu.Unlock()
    s.items[key] = value
}
 
func (sm *ShardedMap[V]) Delete(key string) {
    s := &sm.shards[sm.shard(key)]
    s.mu.Lock()
    defer s.mu.Unlock()
    delete(s.items, key)
}
 
func (sm *ShardedMap[V]) Len() int {
    total := 0
    for i := range sm.shards {
        sm.shards[i].mu.RLock()
        total += len(sm.shards[i].items)
        sm.shards[i].mu.RUnlock()
    }
    return total
}

// ジェネリクスを使った汎用 Singleton パターン
type Singleton[T any] struct {
    once     sync.Once
    value    T
    initFunc func() T
}
 
func NewSingletonT any T) *Singleton[T] {
    return &Singleton[T]{initFunc: init}
}
 
func (s *Singleton[T]) Get() T {
    s.once.Do(func() {
        s.value = s.initFunc()
    })
    return s.value
}
 
// 使用例
var dbSingleton = NewSingleton(func() *sql.DB {
    db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        log.Fatal(err)
    }
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    return db
})
 
func handler(w http.ResponseWriter, r *http.Request) {
    db := dbSingleton.Get()
    // db を使用...
}

// atomic を使ったトークンバケットレートリミッタ
type TokenBucket struct {
    tokens     atomic.Int64
    maxTokens  int64
    refillRate int64 // 1秒あたりの補充数
    lastRefill atomic.Int64
}
 
func NewTokenBucket(maxTokens, refillRate int64) *TokenBucket {
    tb := &TokenBucket{
        maxTokens:  maxTokens,
        refillRate: refillRate,
    }
    tb.tokens.Store(maxTokens)
    tb.lastRefill.Store(time.Now().UnixNano())
    return tb
}
 
func (tb *TokenBucket) refill() {
    now := time.Now().UnixNano()
    last := tb.lastRefill.Load()
    elapsed := float64(now-last) / float64(time.Second)
 
    if elapsed < 0.001 { // 1ms未満は無視
        return
    }
 
    if tb.lastRefill.CompareAndSwap(last, now) {
        newTokens := int64(elapsed * float64(tb.refillRate))
        if newTokens > 0 {
            current := tb.tokens.Load()
            updated := current + newTokens
            if updated > tb.maxTokens {
                updated = tb.maxTokens
            }
            tb.tokens.Store(updated)
        }
    }
}
 
func (tb *TokenBucket) Allow() bool {
    tb.refill()
    for {
        current := tb.tokens.Load()
        if current <= 0 {
            return false
        }
        if tb.tokens.CompareAndSwap(current, current-1) {
            return true
        }
    }
}

// BAD: Mutexを含む構造体をコピー
type Counter struct {
    mu sync.Mutex
    n  int
}
 
func (c Counter) Value() int { // 値レシーバ → コピーされる！
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.n
}
 
// GOOD: ポインタレシーバを使う
func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.n
}
 
// go vet で検出可能: copies lock value

// BAD: 関数全体をロック
func (s *Service) ProcessOrder(order *Order) error {
    s.mu.Lock()
    defer s.mu.Unlock()
 
    validated := validate(order)        // ロック不要な処理
    enriched := enrichData(validated)    // ロック不要な処理
    s.orders[order.ID] = enriched       // これだけロック必要
    return nil
}
 
// GOOD: 必要な箇所だけロック
func (s *Service) ProcessOrder(order *Order) error {
    validated := validate(order)
    enriched := enrichData(validated)
 
    s.mu.Lock()
    s.orders[order.ID] = enriched
    s.mu.Unlock()
    return nil
}

// BAD: ロック順序の不一致によるデッドロック
func transfer(from, to *Account, amount int) {
    from.mu.Lock()   // goroutine1: A → B の順
    to.mu.Lock()     // goroutine2: B → A の順（デッドロック！）
    // ...
}
 
// GOOD: ロック順序を統一する
func transfer(from, to *Account, amount int) {
    // ID の小さい方を先にロック（一貫した順序）
    first, second := from, to
    if from.ID > to.ID {
        first, second = to, from
    }
    first.mu.Lock()
    second.mu.Lock()
    defer first.mu.Unlock()
    defer second.mu.Unlock()
 
    from.Balance -= amount
    to.Balance += amount
}

// BAD: 同じデータに atomic と Mutex を混在させる
type Counter struct {
    mu    sync.Mutex
    count int64
}
 
func (c *Counter) Inc() {
    atomic.AddInt64(&c.count, 1) // atomic で更新
}
 
func (c *Counter) Reset() {
    c.mu.Lock() // Mutex で保護
    c.count = 0
    c.mu.Unlock()
}
// → atomic と Mutex の保護が競合し、データ競合の可能性
 
// GOOD: 一貫した同期メカニズムを使う
type Counter struct {
    count atomic.Int64
}
 
func (c *Counter) Inc()       { c.count.Add(1) }
func (c *Counter) Reset()     { c.count.Store(0) }
func (c *Counter) Value() int64 { return c.count.Load() }

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md