在 serverHTTP 与通道之间有效地实现延迟响应和超时管理方法

为了在 serverHTTP 与通道之间有效实现延迟响应和超时管理，作者提出了几个方法。第一个方法是将 http.responsewriter 传递给工作程序，该工作程序跨越另一个实际执行该作业的工作程序，而“父”工作程序则等待其完成或超时。第二个方法是使用缓冲通道和上下文超时，以便在作业处理完成或超时时通知 servehttp。作者还建议避免长时间保留请求，而是让客户端轮询或使用长轮询来检查作业状态。

我这里有一个概念，我不知道如何正确解决，并对 go 中的系统影响最小。

我正在制作一个“打印后台处理程序”，客户端可以在其中调用 api (/startjob) 来处理打印作业。

由于只有一台打印机，因此瓶颈是一个工作人员一次处理每个作业，但客户端可以在任何给定时间传递一个作业，它只会排队，工作人员将在该时间内处理每个作业这需要一步一步来。

我这样做的方式是 servehttp 将作业推送到通道上（注意这里我只是传递 id，工作人员将从中查找打印数据）：

func (gv *globalvariables) servehttp(w http.responsewriter, r *http.request) {
    
    switch r.url.path {
    case "/startjob":
        newprintjob := queueelement {jobid: "jobid"}
        gv.printqueue <- newprintjob
        fmt.fprintf(w, "instant reply from servehttp\r\n")

    default:
        fmt.fprintf(w, "no such api")
    }
  }

然后，worker 会一直运行并处理传入的任何作业。实际代码还有一点，但最终它会执行一个外部进程：

func worker(jobs <-chan queueelement) {
    for {
        job := <-jobs
        processexec ("start /i /b processandprint.exe -"+job.jobid)
      }

这里的问题是外部进程可能需要一些时间来执行，有时是即时的，但在某些情况下，在返回之前可能需要 1 分钟来执行任务。

我的问题是，现在在 serverhttp 中，我立即写回客户端，不知道该作业是否是第一个并且可以立即处理，或者是否已排队并且可能需要几秒钟的时间，或者距离处理还有几分钟：

fmt.Fprintf(w, "instant reply from serveHTTP\r\n")

我想要的是给客户最多 5 秒的时间来得到回复，如果他的工作在这段时间内得到处理，或者如果没有，告诉他他需要稍后再打电话来检查他的工作状态。

我想到了几种方法：

1. 在我的 queueelemnt 中，我传递了 http.responsewriter，这样我就可以从 worker 写入响应写入器（回复客户端）。如果我让servehttp 休眠，我就可以做到这一点，因为当go 例程存在时，responsewriter 将关闭。所以在这里我需要在servehttp中等待，然后当它等待时，允许工作人员写入responsewriter。

   这种方法的问题在于，如果工作需要几分钟的时间，worker 不会向该 responsewriter 写入任何内容，并且servehttp 不会知道 worker 是否已发送回复。

2. 我可以为每个 queueelement 创建一个通道，这样，servehttp 以及不仅是工作程序，而且是由工作程序处理的实际作业都能够相互通信。

   这种方法我还没有测试过，但我也担心它的杀伤力过大并且对系统造成沉重负担，因为我们可能会遇到这样的情况：我们有很多很多的 api 请求进来，因此正在处理一个大队列，所以即使我需要在 5 秒后超时/取消它，我认为这个概念是多余的？

3. 我也许可以在queueelement中传递一个互斥值，servehttp可以检查长达5秒，队列可以检查/操作，但如果作业完成，queueelement就会消失，所以这可能会导致冲突。

4. 我可以做 1) 的变体，我编写自己的响应编写器，并使用该标志（如果已经写入了某些内容），因此，servehttp 将检查最多 5 秒，以检查是否worker 已经向客户端写了一个回复，在这种情况下退出servehttp，没有答案，或者如果没有写入，则servehttp 会将消息写回客户端，有点类似于此。

但是我觉得这些都不是很顺利，我不想永远启动大量的 go 例程或通道，或者将自己锁定在到处的互斥中，因为我不知道它对系统的影响。

任何人都可以帮助我以正确的方式来实现这样的事情吗？我一直在一页一页地阅读，但还没有找到一种好的、干净的方法来实现这一点。

解决方案

我认为最简单的方法是第一个稍微修改的方法。您可以将 http.responsewriter 传递给工作程序，该工作程序跨越另一个实际执行该作业的工作程序，而“父”工作程序则等待其完成或超时。当两个事件之一先发生时，它将立即回复 http 客户端。

func (gv *globalvariables) servehttp(w http.responsewriter, r *http.request) {

    switch r.url.path {
    case "/startjob":
        newprintjob := queueelement {writer: w, jobid: "jobid"}
        gv.printqueue <- newprintjob
        fmt.fprintf(w, "instant reply from servehttp\r\n")

    default:
        fmt.fprintf(w, "no such api")
    }
  }

func worker(jobs <-chan queueelement) {
    for {
        done := make(chan struct{})
        job := <-jobs

        go func(d chan struct{}, q queueelement) {
            processexec ("start /i /b processandprint.exe -"+q.jobid)
            d <- struct{}{}
        }(done, job)

        select {
            //timeout
            case <-time.after(time.second * 5):
                fmt.fprintf(w, "job is taking more than 5 seconds to complete\r\n")
            //job processing finished in time
            case <-done:
                fmt.fprintf(w, "instant reply from servehttp\r\n")
        }
   }

一旦收到 http 请求，您就可以生成“等待”goroutine。这样，超时计时器将考虑请求/作业的整个处理。

示例：

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func (gv *globalvariables) servehttp(w http.responsewriter, r *http.request) {

    switch r.url.path {
    case "/startjob":
        donec := make(chan struct{}, 1) //buffered channel in order not to block the worker routine
        newprintjob := queueelement{
            donechan: donec,
            jobid:    "jobid",
        }
        go func(donechan chan struct{}) {
            ctx, cancel := context.withtimeout(ctx, 5*time.second)
            defer cancel()
            select {
            //if this triggers first, then this waiting goroutine would exit
            //and nobody would be listeding the 'donechan'. this is why it has to be buffered.
            case <-ctx.done():
                fmt.fprintf(w, "job is taking more than 5 seconds to complete\r\n")
            case <-donechan:
                fmt.fprintf(w, "instant reply from servehttp\r\n")
            }
        }(donec)
        gv.printqueue <- newprintjob

    default:
        fmt.fprintf(w, "no such api")
    }
}

func worker(jobs <-chan queueelement) {
    for {
        job := <-jobs
        processexec("start /i /b processandprint.exe -" + job.jobid)
        job.donechan <- struct{}{}

    }
}

我会避免长时间保留该请求，因为我们不确定何时会处理该作业。

我能想到的一种方法是：

最初从服务器回复接受/排队并返回 job_id。

{
   "job_id": "1",
   "status": "queued"
}

客户端可以轮询（例如每 5 秒一次）或使用长轮询来检查作业的状态。

什么时候运行：

{
   "job_id": "1",
   "status": "processing"
}

完成后：

{
   "job_id": "1",
   "status": "success/failed"
}

今天关于《在 serverHTTP 与通道之间有效地实现延迟响应和超时管理方法》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！