Run function every N seconds with context timeout

Question

I have a basic question about scheduling "cancellable" goroutines.

I want to schedule a function execution, every 3 seconds.

The function can take up to 5 seconds.

In case it takes more than 2999ms I want to stop/terminate it, to avoid overlapping w/ the next one.

I'm doing it wrong:

func main() {
    fmt.Println("startProcessing")
    go startProcessing()

    time.Sleep(time.Second * 60)
    fmt.Println("endProcessing after 60s")
}

func startProcessing() {
    ticker := time.NewTicker(3 * time.Second)
    for _ = range ticker.C {
        ctx, _ := context.WithTimeout(context.Background(), (time.Second*3)-time.Millisecond)

        fmt.Println("start doSomething")
        doSomething(ctx)
    }
}

func doSomething(ctx context.Context) {
    executionTime := time.Duration(rand.Intn(5)+1) * time.Second

    for {
        select {
        case <-ctx.Done():
            fmt.Printf("timed out after %s\n", executionTime)
            return
        default:
            time.Sleep(executionTime)
            fmt.Printf("did something in %s\n", executionTime)
            return
        }
    }
}

This is my output now:

startProcessing

start doSomething

did something in 2s

start doSomething

did something in 3s

start doSomething

did something in 3s

start doSomething

did something in 5s

start doSomething

did something in 2s

...

I want to read timed out after 5s instead of did something in 5s.

You can't abort `time.Sleep`. Context cancellation has no magic in it; all it does is fire a message on its `Done` channel when the timeout is reached. In order to cancel something, that something has to be checking that channel and stopping whatever it's doing. `Sleep` does not. — Adrian, Jun 30 '22 at 13:24

Ricardo Erikson · Accepted Answer · 2022-06-30T14:14:02.270

You just need to put the time.Sleep(executionTime) outside the select and there is no need for the for loop. I think this is somehow what you want but beware that it's not good practice. So take a look at the warning below.

func doSomething(ctx context.Context) {
    executionTime := time.Duration(rand.Intn(5)+1) * time.Second
    processed := make(chan int)

    go func() {
        time.Sleep(executionTime)
        processed <- 1
    }()

    select {
    case <-ctx.Done():
        fmt.Printf("timed out after %s\n", executionTime)
    case <-processed:
        fmt.Printf("did something in %s\n", executionTime)
    }
}

Obs: I changed the original answer a bit. We can not interrupt a goroutine in the middle of its execution. We could delegate the long-running task to another goroutine and receive the result through a dedicated channel.

Warning: I wouldn't recommend that if you expect the processing time to exceed the deadline because now you will have a leaking goroutine.

That won't stop it though, that just means it prints a different message. — Suzu Hirose, Jun 30 '22 at 13:00
Yes! You are right. In addition, there is no way to stop/interrupt a goroutine. I changed the answer a bit, but don't recommend doing that as it's an example of leaking goroutine. — Ricardo Erikson, Jun 30 '22 at 13:36

Run function every N seconds with context timeout

1 Answers1