doutan1875 2018-11-06 06:39
浏览 64


When I add a defer in a function I expect that it will be always called when the function ends. I noticed that it does not happen when the function is times out.

package main

import (

func service1(ctx context.Context, r *Registry) {
    ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
    defer func() {
        r.Unset("service 1")
    r.Set("service 1")
    go service2(ctx, r)

    select {
    case <-ctx.Done():

 func service2(ctx context.Context, r *Registry) {
    defer func() {
        r.Unset("service 2")

    r.Set("service 2")

    time.Sleep(time.Millisecond * 300)

         type Registry struct {
    entries map[string]bool

 func (r *Registry)Set(key string) {
    r.entries[key] = true

 func (r *Registry)Unset(key string)  {
    r.entries[key] = false

 func (r *Registry)Print() {
    for key, val := range r.entries  {
        fmt.Printf("%s -> %v
", key, val)

 func NewRegistry() *Registry {
    r := Registry{}
    r.entries = make(map[string]bool)

    return &r

func main() {
    r := NewRegistry()

    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*200)

    go service1(ctx, r)
    // go service3(ctx, r)

    select {
    case <-ctx.Done():
        fmt.Printf("context err: %s
", ctx.Err())


In the example above, the defer in service2() is never called and that's why the output is:

service 1 -> false
service 2 -> true

instead of

service 1 -> false
service 2 -> false

I understand that timeout means "stop executing" but it's reasonable to me execute deferred code. I could not find any explanation of this behavior.

And the second part of the question - how to modify the service or Registry to be resistant to such situations?

  • 写回答

1条回答 默认 最新

  • dpbv85276 2018-11-06 09:37

    Answer of 1st part

    Say you have a function f1() which uses defer to call f2(), i.e. defer f2() . The fact is that the f2 will be called if and only if f1 completes even if a run-time panic occurs. More specifically, look at go-defer.

    Now our concern is about using defer in goroutine. We also have to remember that a go-routine exits if it's parent function completes of exits.

    So if we use defer in a go-routine function, then if the parent fuction completes or exits, then go-routine function must exit. Since it exits (not completes) the defer statement will not execute. It will be clear we draw the state of your program. enter image description here As you see,

    • at 1st millisecond, service1() completes before others. So, service2() exits without executing defer statement and 'service 2' won't be set to false. Since service1() completes, it's defer will execute and 'service 1' will be set to false.
    • at 2nd millisecond, the main() completes and program finishes.

    So we see how this program executes.

    Answer of 2nd part

    One possible solution i tried is increase time in service1() or decrease time in service2().

    本回答被题主选为最佳回答 , 对您是否有帮助呢?



  • ¥60 pb数据库修改或者求完整pb库存系统,需为pb自带数据库
  • ¥15 spss统计中二分类变量和有序变量的相关性分析可以用kendall相关分析吗?
  • ¥15 拟通过pc下指令到安卓系统,如果追求响应速度,尽可能无延迟,是不是用安卓模拟器会优于实体的安卓手机?如果是,可以快多少毫秒?
  • ¥20 神经网络Sequential name=sequential, built=False
  • ¥16 Qphython 用xlrd读取excel报错
  • ¥15 单片机学习顺序问题!!
  • ¥15 ikuai客户端多拨vpn,重启总是有个别重拨不上
  • ¥20 关于#anlogic#sdram#的问题,如何解决?(关键词-performance)
  • ¥15 相敏解调 matlab
  • ¥15 求lingo代码和思路