Question

我有以下代码：

var (
    WorkersNum int = 12
    HTTPAddr string = "127.0.0.1:8080"
    Delay = 3e9
)

var (
    RequestQueue = make(chan Request, 1024)
    WorkerQueue chan chan Request
)

type Request struct {
    Buf []byte
    Delay time.Duration
}

type Worker struct {
    ID          int
    Request     chan Request
    WorkerQueue chan chan Request
    QuitChan    chan bool
}

func main() {
    fmt.Println("Starting the dispatcher")
    StartDispatcher()

    fmt.Println("Registering the handler")
    http.HandleFunc("/", handleRequest)

    fmt.Println("HTTP server listening on", HTTPAddr)
    if err := http.ListenAndServe(HTTPAddr, nil); err != nil {
        fmt.Println(err.Error())
    }
}

func StartDispatcher() {
    WorkerQueue = make(chan chan Request, WorkersNum)

    for i := 0; i < WorkersNum; i++ {
        fmt.Println("Starting worker", i + 1)
        worker := NewWorker(i + 1, WorkerQueue)
        worker.Start()
    }

    go func() {
        for {
            select {
            case request := <-RequestQueue:
                    fmt.Println("Received requeust")
                    go func() {
                        worker := <-WorkerQueue
                        fmt.Println("Dispatching request")
                        worker <- request
                    }()
            }
        }
    }()
}

func NewWorker(id int, workerQueue chan chan Request) Worker {
    worker := Worker{
        ID:          id,
        Request:     make(chan Request),
        WorkerQueue: workerQueue,
        QuitChan:    make(chan bool),
    }
    return worker
}

func (w *Worker) Start() {
    go func() {
        for {
            w.WorkerQueue <- w.Request
            select {
            case request := <-w.Request:
                    fmt.Printf("worker%d: Received work request, delaying for %f seconds\n", w.ID, request.Delay.Seconds())
                    time.Sleep(request.Delay)
                    writeToFile(request.Buf)
                    fmt.Printf("worker%d: Saved to file!\n", w.ID)
                case <-w.QuitChan:
                    fmt.Printf("worker%d stopping\n", w.ID)
                    return
            }
        }
    }()
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // make sure it's POST
    if r.Method != "POST" {
        w.Header().Set("Allow", "POST")
        w.WriteHeader(http.StatusMethodNotAllowed)
        return
    }
    // add cors
    w.Header().Set("Access-Control-Allow-Origin", "*")
    // retrieve
    buf, err := ioutil.ReadAll(r.Body)
    if err != nil {
        //http.Error(w, err, http.StatusBadRequest)
        return
    }
    request := Request{Buf: buf, Delay: Delay}
    RequestQueue <- request
    fmt.Println("Request queued")
}

我很擅长语言和日常工作 - 你能帮助我理解这段代码是如何运作的吗？

首先，我在每个worker上调用start（）函数，将Worker.Request分配给Worker.WorkerQueue - 如何将空通道分配给空的通道数组？

然后在StartDispatcher（）中创建等待请求的go例程。

当请求到来时，我将它添加到RequestQueue变量。下一步是什么？应该触发Start（）函数，但是case正在等待w.Request。哪个没有填充，因为它的RequestQueue变量会发生变化。

你能给我一些简单的解释吗？

Answer 1

我不喜欢go func() {...} 里面 Worker.Start（），IMO Worker.Start（）必须是同步的，那么你必须在StartDispatcher中将其称为go worker.Start()（）。

工作原理。

在StartDispatcher（）中，它在循环中创建工作程序，而循环又将其输入通道放在WorkerQueue缓冲通道上（缓冲通道的工作方式类似于数组，但通道）和块等待请求。然后我们启动一个新的goroutine来处理传入的请求：从缓冲的通道WorkerQueue中选择第一个 worker的输入通道（工作变量）并向其发送请求。

工作人员会选择它，完成工作，然后进入下一个周期：将他的输入通道输入WorkerQueue（是的，它是StartDispatcher（）启动时第一次完成的地方）。

任何时候你可以关闭工人QuitChan，工人将在case <-w.QuitChan案件中终止（从封闭渠道中读取，立即返回）。

顺便说一句，您的RequestQueue = make(chan Request, 1024)也是缓冲通道，因此对它的写入不会阻止（除非它已满）。

希望它有所帮助。

使用go例程排队ajax请求

1 个答案: