Practical sharing of concurrent calling of Golang functions

As an efficient, lightweight programming language with good concurrency support, Golang's concurrent function calling is a very important feature. In this article, this article will share some practical experience about concurrent calls of Golang functions, hoping to be helpful to Golang developers.

1. The use of Goroutine

Goroutine is the basis for Golang to achieve concurrency. Using Goroutine to call a function is very simple, just add the go keyword in front of the function:

go funcName()

The code shown above can call the funcName function in a new Goroutine. The specific code implementation and parameters of the calling function depend on the situation.

2. Call a group of functions concurrently

In Golang, a group of functions can be called at the same time. Using sync.WaitGroup can help coordinate the tasks performed by different Goroutines. The following is a sample code that calls a group of functions concurrently:

// 定义一个 WaitGroup 
var wg sync.WaitGroup

func main() {
    // 增加 WaitGroup 的计数器值
    wg.Add(3)

    // 并发调用 3 个函数
    go func1()
    go func2()
    go func3()

    // 等待所有进行中的 Goroutines 完成任务
    wg.Wait()
}

// func1 函数
func func1() {
    // 告诉 WaitGroup 函数执行完毕
    defer wg.Done()

    // 执行 func1 的操作
}

// func2 函数
func func2() {
    // 告诉 WaitGroup 函数执行完毕
    defer wg.Done()

    // 执行 func2 的操作
}

// func3 函数
func func3() {
    // 告诉 WaitGroup 函数执行完毕
    defer wg.Done()

    // 执行 func3 的操作
}

3. Use channels to implement concurrent calls

Using channels allows multiple Goroutines to communicate with each other and implement concurrent calls. The following is a sample code for concurrently calling a set of functions:

func main() {
    // 定义 channel
    c := make(chan int)

    // 并发调用 3 个函数
    go func1(c)
    go func2(c)
    go func3(c)

    // 等待所有 Goroutine 执行完毕
    for i := 0; i < 3; i++ {
        <-c
    }
}

// func1 函数
func func1(c chan<- int) {
    // 执行 func1 的操作

    // 发送信号
    c <- 1
}

// func2 函数
func func2(c chan<- int) {
    // 执行 func2 的操作

    // 发送信号
    c <- 2
}

// func3 函数
func func3(c chan<- int) {
    // 执行 func3 的操作

    // 发送信号
    c <- 3
}

4. Use multiple channels to implement concurrent calls

If you need to pass multiple parameters or data in different Goroutines, you can use Multiple channels implement concurrent calls. The following is a sample code that calls a group of functions concurrently:

func main() {
    // 定义 channel
    c1 := make(chan int)
    c2 := make(chan string)

    // 并发调用 3 个函数
    go func1(c1, c2)
    go func2(c2)
    go func3(c1)

    // 等待所有 Goroutine 执行完毕
    for i := 0; i < 2; i++ {
        <-c1
    }
}

// func1 函数
func func1(c1 chan<- int, c2 chan<- string) {
    // 执行 func1 的操作

    // 发送数据
    c1 <- 1
    c2 <- "hello"
}

// func2 函数
func func2(c2 <-chan string) {
    // 执行 func2 的操作

    // 读取数据
    data := <-c2
}

// func3 函数
func func3(c1 <-chan int) {
    // 执行 func3 的操作

    // 读取数据
    data := <-c1
}

The above is a practical experience sharing about concurrent calling of Golang functions. By properly using Goroutine, channel and sync.WaitGroup, efficient, safe and reliable concurrent calls of multiple functions can be achieved. In practice, you also need to pay attention to reasonably controlling the number of Goroutines to avoid problems such as deadlock and resource competition.

The above is the detailed content of Practical sharing of concurrent calling of Golang functions. For more information, please follow other related articles on the PHP Chinese website!