// 讀操作協(xié)議：包含鍵和響應(yīng)通道
type ReadOp struct {
    key  int       // 讀取的鍵
    resp chan int   // 響應(yīng)通道，返回對(duì)應(yīng)值
}

// 寫操作協(xié)議：包含鍵、值和響應(yīng)通道
type WriteOp struct {
    key  int       // 寫入的鍵
    val  int       // 寫入的值
    resp chan bool  // 響應(yīng)通道，返回操作成功狀態(tài)
}

func stateManager(reads chan ReadOp, writes chan WriteOp) {
    state := make(map[int]int) // 私有狀態(tài)：僅該goroutine可訪問
    for {
        select {
        case readReq := <-reads:
            // 處理讀請(qǐng)求：從state獲取值并通過響應(yīng)通道返回
            readReq.resp <- state[readReq.key]
        case writeReq := <-writes:
            // 處理寫請(qǐng)求：更新state并通過響應(yīng)通道通知成功
            state[writeReq.key] = writeReq.val
            writeReq.resp <- true
        }
    }
}

func readFromState(reads chan ReadOp, key int) int {
    resp := make(chan int)
    reads <- ReadOp{key: key, resp: resp} // 發(fā)送讀請(qǐng)求
    return <-resp // 阻塞等待響應(yīng)
}

func writeToState(writes chan WriteOp, key, val int) bool {
    resp := make(chan bool)
    writes <- WriteOp{key: key, val: val, resp: resp} // 發(fā)送寫請(qǐng)求
    return <-resp // 獲取操作結(jié)果
}

func counterService() {
    reads := make(chan ReadOp)
    writes := make(chan WriteOp)
    go stateManager(reads, writes) // 啟動(dòng)狀態(tài)持有g(shù)oroutine

    // 模擬客戶端請(qǐng)求
    go func() {
        for i := 0; i < 1000; i++ {
            writeToState(writes, 1, i) // 寫入計(jì)數(shù)
        }
    }()

    go func() {
        for i := 0; i < 100; i++ {
            fmt.Println("Current count:", readFromState(reads, 1)) // 讀取計(jì)數(shù)
        }
    }()
}

type CacheItem struct {
    Value      interface{}
    Expiration time.Time
}

func cacheManager() {
    reads := make(chan ReadOp)
    writes := make(chan WriteOp)
    cache := make(map[int]CacheItem)

    go func() {
        for {
            select {
            case req := <-reads:
                req.resp <- cache[req.key] // 返回緩存項(xiàng)
            case req := <-writes:
                cache[req.key] = CacheItem{ // 更新緩存
                    Value:      req.val,
                    Expiration: time.Now().Add(5 * time.Minute),
                }
                req.resp <- true
            }
        }
    }()
}

type LockRequest struct {
    Key   string
    Resp  chan bool // 鎖獲取結(jié)果
}

func lockService() {
    locks := make(map[string]bool) // 記錄鎖的持有狀態(tài)
    requests := make(chan LockRequest)

    go func() {
        for req := range requests {
            if !locks[req.Key] {
                locks[req.Key] = true
                req.Resp <- true // 鎖獲取成功
            } else {
                req.Resp <- false // 鎖已被占用
            }
        }
    }()

    // 客戶端獲取鎖
    func tryLock(key string) bool {
        resp := make(chan bool)
        requests <- LockRequest{Key: key, Resp: resp}
        return <-resp
    }
}

type WriteOp struct {
    key    int
    val    int
    version int // 操作版本號(hào)
    resp   chan bool
}

func readWithTimeout(reads chan ReadOp, key int, timeout time.Duration) (int, error) {
    resp := make(chan int)
    reads <- ReadOp{key: key, resp: resp}
    select {
    case val := <-resp:
        return val, nil
    case <-time.After(timeout):
        return 0, fmt.Errorf("read timeout")
    }
}