php小编新一在处理HTTP请求时，是否必须监听请求上下文取消是一个常见的疑问。在实际开发中，通常情况下并不需要显式地监听请求上下文取消，因为PHP的运行环境会自动处理相关的资源释放工作。但是，在某些特殊情况下，比如需要手动释放资源或执行一些清理操作时，监听请求上下文取消可以是一种有效的方式。因此，是否需要监听请求上下文取消取决于具体的业务需求和开发场景。对于大部分情况下，我们可以放心地依赖PHP的自动资源管理机制。
问题内容
假设我正在编写一个 http 处理程序，在返回响应之前执行其他操作，我是否必须设置一个侦听器来检查 http 请求上下文是否已被取消？以便它可以立即返回，或者当请求上下文取消时是否有其他方法退出处理程序？
func handlesomething(w http.responsewriter, r *http.request) {
done := make(chan error)
go func() {
if err := dosomething(r.context()); err != nil {
done <- err
return
}
done <- nil
}()
select {
case <-r.context().done():
http.error(w, r.context().err().error(), http.statusinternalservererror)
return
case err := <-done:
if err != nil {
http.error(w, err.error(), http.statusinternalservererror)
return
}
w.writeheader(http.statusok)
w.write([]byte("ok"))
}
}
func dosomething(ctx context.context) error {
// simulate doing something for 1 second.
time.sleep(time.second)
return nil
}
我尝试对其进行测试，但是在上下文取消后，dosomething函数并没有停止并且仍在后台运行。
func TestHandler(t *testing.T) {
mux := http.NewServeMux()
mux.HandleFunc("/something", handleSomething)
srv := http.Server{
Addr: ":8989",
Handler: mux,
}
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
if err := srv.ListenAndServe(); err != nil {
log.Println(err)
}
}()
time.Sleep(time.Second)
req, err := http.NewRequest(http.MethodGet, "http://localhost:8989/something", nil)
if err != nil {
t.Fatal(err)
}
cl := http.Client{
Timeout: 3 * time.Second,
}
res, err := cl.Do(req)
if err != nil {
t.Logf("error: %s", err.Error())
} else {
t.Logf("request is done with status code %d", res.StatusCode)
}
go func() {
<-time.After(10 * time.Second)
shutdown, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
srv.Shutdown(shutdown)
}()
wg.Wait()
}
func handleSomething(w http.ResponseWriter, r *http.Request) {
done := make(chan error)
go func() {
if err := doSomething(r.Context()); err != nil {
log.Println(err)
done <- err
}
done <- nil
}()
select {
case <-r.Context().Done():
log.Println("context is done!")
return
case err := <-done:
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Write([]byte("ok"))
}
}
func doSomething(ctx context.Context) error {
return runInContext(ctx, func() {
log.Println("doing something")
defer log.Println("done doing something")
time.Sleep(10 * time.Second)
})
}
func runInContext(ctx context.Context, fn func()) error {
ch := make(chan struct{})
go func() {
defer close(ch)
fn()
}()
select {
case <-ctx.Done():
return ctx.Err()
case <-ch:
return nil
}
}解决方法
我刚刚对提供的解决方案进行了一些重构，现在它应该可以工作了。让我指导您完成相关更改。
dosomething 函数
func dosomething(ctx context.context) error {
fmt.printf("%v - dosomething: start\n", time.now())
select {
case <-ctx.done():
fmt.printf("%v - dosomething: cancelled\n", time.now())
return ctx.err()
case <-time.after(3 * time.second):
fmt.printf("%v - dosomething: processed\n", time.now())
return nil
}
}
它等待取消输入，或者在延迟 3 秒后返回给调用者。它接受要侦听的上下文。
handlesomething 函数
func handlesomething(w http.responsewriter, r *http.request) {
ctx := r.context()
fmt.printf("%v - handlerequestctx: start\n", time.now())
done := make(chan error)
go func() {
if err := dosomething(ctx); err != nil {
fmt.printf("%v - handlerequestctx: error %v\n", time.now(), err)
done <- err
}
done <- nil
}()
select {
case <-ctx.done():
fmt.printf("%v - handlerequestctx: cancelled\n", time.now())
return
case err := <-done:
if err != nil {
fmt.printf("%v - handlerequestctx: error: %v\n", time.now(), err)
w.writeheader(http.statusinternalservererror)
return
}
fmt.printf("%v - handlerequestctx: processed\n", time.now())
}
}
这里的逻辑和你的非常相似。在 select 中，我们检查接收到的错误是否为 nil ，并据此向调用者返回正确的 http 状态代码。如果我们收到取消输入，我们就会取消所有上下文链。
testhandler 函数
func TestHandler(t *testing.T) {
r := mux.NewRouter()
r.HandleFunc("/demo", handleSomething)
srv := http.Server{
Addr: ":8000",
Handler: r,
}
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
if err := srv.ListenAndServe(); err != nil {
fmt.Println(err.Error())
}
}()
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, 1*time.Second) // request canceled
// ctx, cancel := context.WithTimeout(ctx, 5*time.Second) // request processed
defer cancel()
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "http://localhost:8000/demo", nil)
client := http.Client{}
res, err := client.Do(req)
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Printf("res status code: %d\n", res.StatusCode)
}
srv.Shutdown(ctx)
wg.Wait()
}
在这里，我们启动一个 http 服务器并通过 http.client 向它发出 http 请求。可以看到有两条语句来设置上下文超时。如果您使用带有注释 // request canceled 的，则所有内容都会被取消，否则，如果您使用另一个，则请求将被处理。
我希望这能澄清您的问题！
