select - Go Golang select 语句无法接收发送的值

Question

我是 Go 的新手，正在尝试实现一个简单的负载均衡器，如本幻灯片所示: http://concur.rspace.googlecode.com/hg/talk/concur.html#slide-42

完整代码:

package main

import (
    "fmt"
    "time"
    "container/heap"
)

type Request struct {
    fn func(*Worker) int
    c  chan int
}

func requester(work chan <-Request) {
    c := make(chan int)
    work <- Request{workFn, c}
    result := <-c
    furtherProcess(result)
}

func workFn(w *Worker) int {
    time.Sleep(1000 * time.Millisecond)
    return w.index
}

func furtherProcess(result int) {
    fmt.Println(result)
}

type Worker struct {
    request chan Request
    pending int
    index   int
}

func (w *Worker) work(done chan *Worker) {
    for req := range w.request {
        req.c <- req.fn(w)
        fmt.Println("sending to done:", done)
        done <- w
        fmt.Println("sended to done")
    }
}

type Pool []*Worker

type Balancer struct {
    pool Pool
    done chan *Worker
}

func (b *Balancer) balance(work chan Request) {
    for {
        fmt.Println("selecting, done:", b.done)
        select {
        case req := <-work:
            b.dispatch(req)
        case w := <-b.done:
            fmt.Println("completed")
            b.completed(w)
        }
    }
}

func (p Pool) Len() int {
    return len(p)
}

func (p Pool) Less(i, j int) bool {
    return p[i].pending < p[j].pending
}

func (p Pool) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

func (p *Pool) Push(x interface{}) {
    *p = append(*p, x.(*Worker))
}

func (p *Pool) Pop() interface{} {
    old := *p
    n := len(old)
    x := old[n - 1]
    *p = old[0 : n - 1]
    return x
}

func (b *Balancer) dispatch(req Request) {
    w := heap.Pop(&b.pool).(*Worker)
    w.request <- req
    w.pending++
    heap.Push(&b.pool, w)
    fmt.Println("dispatched to worker", w.index)
}

func (b *Balancer) completed(w *Worker) {
    w.pending--
    heap.Remove(&b.pool, w.index)
    heap.Push(&b.pool, w)
}

func Run() {
    NumWorkers := 4
    req := make(chan Request)
    done := make(chan *Worker)
    b := Balancer{make([]*Worker, NumWorkers), done}
    for i := 0; i < NumWorkers; i++ {
        w := Worker{make(chan Request), 0, i}
        b.pool[i] = &w
        go w.work(done)
    }
    go b.balance(req)
    for i := 0; i < NumWorkers * 4; i++ {
        go requester(req)
    }
    time.Sleep(200000 * time.Millisecond)
}

func main() {
    Run()
}

当我运行它时，我得到了以下输出:

selecting, done: 0xc0820082a0
dispatched to worker 0
selecting, done: 0xc0820082a0
dispatched to worker 3
selecting, done: 0xc0820082a0
dispatched to worker 2
selecting, done: 0xc0820082a0
dispatched to worker 1
selecting, done: 0xc0820082a0
sending to done: 0xc0820082a0
sending to done: 0xc0820082a0
3
sending to done: 0xc0820082a0
2
1
0
sending to done: 0xc0820082a0

如您所见，它正在选择并发送到同一个管道(完成:0xc0820082a0)，但是选择没有收到发送的值并且永远阻塞。怎么会这样？上面的代码有什么问题？谢谢!

Answer 1

使用 kill -ABRT <PID> 你可以看到你所有的 worker 都在 done <- w 上被阻止了当您的 Balancer 在 w.request <- req 上被阻止时，造成死锁(在平衡器收到他们的“完成”信号之前，工作人员不能走得更远，而在选定的工作人员接受请求之前，平衡器不能走得更远)。

如果你替换done <- w通过 go func() { done <- w }() ，您可以看到您的程序将处理这 16 个请求而不会挂起。

旁注:而不是 time.Sleep(200000 * time.Millisecond) , 查看 sync.WaitGroup