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>，您可以看到done <- w上的所有工作人员在w.request <- req上被阻止，而done <- w阻止了您的Balancer，造成僵局（工作人员无法继续平衡器收到他们的完成＆＃34;信号，平衡器不能再进一步直到所选工人接受请求。）

如果您将go func() { done <- w }()替换为time.Sleep(200000 * time.Millisecond)，则可以看到您的程序将处理16个请求而不会挂起。

旁注：代替<uses-feature android:name="android.hardware.location.gps" android:required="false" />，请查看sync.WaitGroup

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

1 个答案: