Ask Go to run all goroutines before continuing

When doing concurrent programming, we often encounter situations where we need to wait for all goroutines to complete before continuing execution. In Go language, we can achieve this goal by using WaitGroup. WaitGroup is a counting semaphore that can be used to wait for the completion of a group of goroutines. Before continuing, we need to call the Wait method of WaitGroup to ensure that all goroutines have completed their tasks. In this article, we will introduce how to correctly use WaitGroup to manage the execution order of goroutines.

Question content

I need the golang scheduler to run all goroutines before continuing, runtime.gosched() cannot solve it.

The problem is that the go routine runs so fast that the "select" in start() runs after the "select" in stopstream(), and then the "case <-chanstopstream:" receiver is not ready to send Filed by "case retchan <-true:". The result is that when this happens, the result is the same behavior as when stopstream() hangs

Run this code https://go.dev/play/p/dq85xqju2q_z Many times you will see these two responses Expected response when not suspended:

2009/11/10 23:00:00 start
2009/11/10 23:00:00 receive chan
2009/11/10 23:00:03 end

Expected response when suspended, but the response when suspended is not that fast:

2009/11/10 23:00:00 start
2009/11/10 23:00:00 default
2009/11/10 23:00:01 timer
2009/11/10 23:00:04 end

Code

package main

import (
    "log"
    "runtime"
    "sync"
    "time"
)

var wg sync.WaitGroup

func main() {
    wg.Add(1)
    //run multiples routines on a huge system
    go start()
    wg.Wait()
}
func start() {
    log.Println("Start")
    chanStopStream := make(chan bool)
    go stopStream(chanStopStream)
    select {
    case <-chanStopStream:
        log.Println("receive chan")
    case <-time.After(time.Second): //if stopStream hangs do not wait more than 1 second
        log.Println("TIMER")
        //call some crash alert
    }
    time.Sleep(3 * time.Second)
    log.Println("end")
    wg.Done()
}

func stopStream(retChan chan bool) {
    //do some work that can be faster then caller or not
    runtime.Gosched()
    //time.Sleep(time.Microsecond) //better solution then runtime.Gosched()
    //time.Sleep(2 * time.Second) //simulate when this routine hangs more than 1 second
    select {
    case retChan <- true:
    default: //select/default is used because if the caller times out this routine will hangs forever
        log.Println("default")
    }
}

Workaround

There is no way to run all other goroutines before continuing execution of the current goroutine.

Fix the problem by ensuring that the goroutine does not block on stopstream:

Option 1: Change chanstopstream to buffered channel. This ensures that stopstream can send values ​​without blocking.

func start() {
    log.println("start")
    chanstopstream := make(chan bool, 1) // <--- buffered channel
    go stopstream(chanstopstream)
    ...
}

func stopstream(retchan chan bool) {
    ...
    // always send. no select/default needed.
    retchan <- true
}

//m.sbmmt.com/link/56e48d306028f2a6c2ebf677f7e8f800

Option 2: Close the channel instead of sending the value. Channels can always be closed by the sender. Receives a zero value on a closed channel that returns the channel value type.

func start() {
    log.Println("Start")
    chanStopStream := make(chan bool) // buffered channel not required
    go stopStream(chanStopStream)
    ...

func stopStream(retChan chan bool) {
    ...
    close(retChan)
}

//m.sbmmt.com/link/a1aa0c486fb1a7ddd47003884e1fc67f

The above is the detailed content of Ask Go to run all goroutines before continuing. For more information, please follow other related articles on the PHP Chinese website!