Go语言有状态goroutine的具体使用

// 读操作协议：包含键和响应通道
type ReadOp struct {
    key  int       // 读取的键
    resp chan int   // 响应通道，返回对应值
}

// 写操作协议：包含键、值和响应通道
type WriteOp struct {
    key  int       // 写入的键
    val  int       // 写入的值
    resp chan bool  // 响应通道，返回操作成功状态
}

func stateManager(reads chan ReadOp, writes chan WriteOp) {
    state := make(map[int]int) // 私有状态：仅该goroutine可访问
    for {
        select {
        case readReq := <-reads:
            // 处理读请求：从state获取值并通过响应通道返回
            readReq.resp <- state[readReq.key]
        case writeReq := <-writes:
            // 处理写请求：更新state并通过响应通道通知成功
            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} // 发送读请求
    return <-resp // 阻塞等待响应
}

func writeToState(writes chan WriteOp, key, val int) bool {
    resp := make(chan bool)
    writes <- WriteOp{key: key, val: val, resp: resp} // 发送写请求
    return <-resp // 获取操作结果
}

func counterService() {
    reads := make(chan ReadOp)
    writes := make(chan WriteOp)
    go stateManager(reads, writes) // 启动状态持有goroutine

    // 模拟客户端请求
    go func() {
        for i := 0; i < 1000; i++ {
            writeToState(writes, 1, i) // 写入计数
        }
    }()

    go func() {
        for i := 0; i < 100; i++ {
            fmt.Println("Current count:", readFromState(reads, 1)) // 读取计数
        }
    }()
}

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] // 返回缓存项
            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 // 锁获取结果
}

func lockService() {
    locks := make(map[string]bool) // 记录锁的持有状态
    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 // 操作版本号
    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")
    }
}