The parent-child relationship between golang functions and goroutine

There is a parent-child relationship between functions and goroutines in Go. The parent goroutine creates the child goroutine, and the child goroutine can access the variables of the parent goroutine but not vice versa. Create a child goroutine using the go keyword. The child goroutine is executed through an anonymous function or a named function. A parent goroutine can wait for child goroutines to complete via sync.WaitGroup to ensure that the program does not exit before all child goroutines have completed.

The parent-child relationship between Go language functions and goroutine

In the Go language, goroutine is a function that is executed concurrently. Goroutines are organized in a parent-child relationship, with parent goroutine creating child goroutines. The child goroutine has access to the parent goroutine's variables, but the parent goroutine cannot access the child goroutine's variables.

Create a child goroutine

Use the go keyword to create a child goroutine:

go func() {
  // 子 goroutine 代码
}

The child goroutine executes an anonymous function. Similarly, we can pass named functions to go Keywords:

func child() {
  // 子 goroutine 代码
}

go child()

Access parent goroutine variables

Child goroutine can access local variables of parent goroutine without explicit type transfer. This is because the goroutine executes in the same memory space. For example:

func parent() {
  count := 10
  go func() {
    fmt.Println(count) // 输出 10
  }()
}

Child goroutine can safely access and modify the variables of the parent goroutine. However, due to concurrency, locks or other synchronization mechanisms must be used to prevent data races.

The parent goroutine waits for the child goroutine

The parent goroutine can use sync.WaitGroup to wait for the child goroutine to complete. WaitGroup Tracks the number of remaining sub-goroutines and provides Add and Wait methods:

func parent() {
  var wg sync.WaitGroup
  wg.Add(1)
  go func() {
    defer wg.Done()
    // 子 goroutine 代码
  }()

  wg.Wait() // 等待子 goroutine 完成
}

Practical case: File Downloader

Consider a parallel file downloader that downloads files from multiple remote URLs. We can use goroutines for concurrent downloading as follows:

func main() {
  var wg sync.WaitGroup

  urls := []string{"url1", "url2", "url3"}

  for _, url := range urls {
    wg.Add(1)
    go func(url string) {
      defer wg.Done()
      downloadFile(url)
    }(url)
  }

  wg.Wait() // 等待所有文件下载完成
}

In this case, the main goroutine creates child goroutines to download each file. The main goroutine uses WaitGroup to wait for all child goroutines to complete, ensuring that the program does not exit before all files have been downloaded.

Conclusion

Understanding the parent-child relationship between functions and goroutines is crucial to building robust parallel Go programs. By understanding variable access and goroutine synchronization mechanisms, we can create high-performance concurrent applications.

The above is the detailed content of The parent-child relationship between golang functions and goroutine. For more information, please follow other related articles on the PHP Chinese website!