How to make this golang for-select code work?

Question

Question

How to make the below code print "QUIT" after 3 seconds?

Code

package main

import (
    "fmt"
    "time"
)

func main() {
    quit := make(chan struct{})
    tasks := make(chan struct{})

    go func(){
      time.Sleep(1 * time.Second)
      tasks <- struct{}{}
    }()

    go func(){
      time.Sleep(3 * time.Second)
      quit <- struct{}{}
    }()

    for {
        select {
        case <-quit:
            fmt.Println("QUIT")
            return
        case <-tasks:
            fmt.Println("Doing")
            // do some long time jobs more than 10 seconds
            time.Sleep(10 * time.Second)
        }
    }
}

Observations

The above code prints "Doing". and sleep 10 seconds, then print "QUIT". How to interrupt this sleep, let it receive quit channel after 3 seconds and print "QUIT"?

It seems select is blocked by case tasks, and it will not receive from the quit channel after 3 seconds.

*It seems select is blocked by case tasks* No, the program just ends since you return. — super, Apr 28 '21 at 06:24
*How to interrupt this sleep* - what problem are you trying to solve here? "Kill" a blocking operation? — FObersteiner, Apr 28 '21 at 06:34
How to make it quit after 3 seconds? I've updated this question. — Max Xu, Apr 28 '21 at 06:34
Assume there is a time consuming job inside `case tasks`, which longer than 10 seconds, So how can I interrupt this job when I send a `quit` channel signal? — Max Xu, Apr 28 '21 at 06:39
you would not run the time-consuming (and blocking) job in `main`. use a goroutine which you can cancel, see e.g. https://stackoverflow.com/a/47302930/10197418 — FObersteiner, Apr 28 '21 at 06:41
See also this https://golangbyexample.com/select-statement-with-timeout-go/ — Matteo, Apr 28 '21 at 07:18

score 2 · Answer 1 · answered Apr 28 '21 at 08:12

To signal end of an asynchronous task it is a best practice to close the channel, this is rather important to prevent many missuse that leads to various deadlocks. In your original code I would have written close(quite) rather than quit <- struct{}{} Remember, read on a closed does not block and always return the zero value, that is the trick.

Anyways, appart from this, an elegant way to solve your problem is to use a combination of both context.Context and time.After.

time.After will help you block on a selectable task set.

context.Context is better suited to handle this kind of signals.

https://play.golang.org/p/ZVsZw3P-YHd

package main

import (
    "context"
    "log"
    "time"
)

func main() {
    log.Println("start")
    defer log.Println("end")
    ctx, cancel := context.WithCancel(context.Background())
    tasks := make(chan struct{})

    go func() {
        time.Sleep(1 * time.Second) // a job
        tasks <- struct{}{}
    }()

    go func() {
        time.Sleep(3 * time.Second) // a job
        cancel()
    }()

    for {
        select {
        case <-ctx.Done():
            log.Println("QUIT")
            return
        case <-tasks:
            log.Println("Doing")
            // do some long time jobs more than 10 seconds
            select {
            case <-ctx.Done():
                return
            case <-time.After(time.Second * 10):
            }
        }
    }
}

score 0 · Answer 2 · answered Apr 28 '21 at 08:07

The second job is running for 10 seconds, so it will block the loop for that time, and the signal you sent into the quit channel will not be received until this job is complete.

To interrupt the time-consuming job, maybe you can split it into another goroutine. Something like this would do:

go func() {
  for {
    select {
    case <-tasks:
      fmt.Println("Doing")
      // do some long time jobs more than 10 seconds
      time.Sleep(10 * time.Second)
    }   
  }   
}() 

<-quit
fmt.Println("QUIT")

score 0 · Answer 3 · answered May 20 '21 at 02:29

It would be easier to use [sync.WaitGroup.

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(msg string, duration time.Duration, doing bool, wg *sync.WaitGroup) {
    defer wg.Done()
    time.Sleep(duration)

    fmt.Println(msg)

    if doing {
        time.Sleep(10 * time.Second)
    }
}

func main() {

    var wg sync.WaitGroup
    msgs := [2]string{"QUIT", "Doing"}
    durations := [2]time.Duration{3 * time.Second, 1 * time.Second}
    doing := [2]bool{false, true}

    for i, msg := range msgs {
        wg.Add(1)

        go worker(msg, durations[i], doing[i], &wg)
    }

    wg.Wait()
}

How to make this golang for-select code work?

Question

Code

Observations

3 Answers3