Golang function and goroutine life cycle

Function Life Cycle: Declaration and Compilation: The compiler verifies the syntax and type of the function. Execution: Executed when the function is called. Return: Return to the calling location after execution. Goroutine life cycle: Creation and startup: Create and start through the go keyword. Execution: Runs asynchronously until the task is completed. End: The task ends when it is completed or an error occurs. Cleanup: The garbage collector cleans up the memory occupied by the finished Goroutine.

The life cycle of Golang functions and Goroutine

The life cycle of functions

In Golang, functions are compiled immediately after they are declared, and Execution occurs at runtime. The life cycle of a function is as follows:

1. Declaration and Compilation: The compiler parses and verifies the syntax and type of the function.
2. Execution: The function will be executed only when the code is executed to the function call.
3. Return: After the function is executed, the control flow returns to the location where it was called.

The life cycle of Goroutine

Goroutine is a lightweight thread in the Go language. Its life cycle is as follows:

1. Creation and startup: Create Goroutine through the go keyword and start it immediately.
2. Execution: Goroutine runs asynchronously until it completes its task.
3. End: When a Goroutine completes its task or an error occurs, it ends.
4. Cleaning: The garbage collector will automatically clean up the memory occupied by the finished Goroutine.

Practical case: executing tasks in parallel

Consider the following case: we want to execute multiple tasks in parallel, such as computing a list of prime numbers.

package main

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

// 函数检查给定数字是否是素数。
func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    // 创建一个等待组以等待所有 Goroutine 完成。
    var wg sync.WaitGroup

    // 创建和启动一个 Goroutine 来检查每个数字是否是素数。
    for i := 1; i <= 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done() // Goroutine 完成后调用 Done() 以减少等待组计数。
            if isPrime(i) {
                fmt.Println(i)
            }
        }(i)
    }

    // 等待所有 Goroutine 完成。
    wg.Wait()
}

In this case:

• isPrime The function is responsible for checking whether the given number is prime.
• main Function creates and starts a Goroutine to check in parallel whether each number is prime.
• sync.WaitGroup Used to ensure that the main program does not exit before all Goroutines are completed.
• defer wg.Done() Ensures that each Goroutine decrements the wait group count upon completion.

The above is the detailed content of Golang function and goroutine life cycle. For more information, please follow other related articles on the PHP Chinese website!