How to use Go language for concurrent programming?

With the continuous development of computer hardware, the CPU cores in the processor no longer increase the clock frequency individually, but increase the number of cores. This raises an obvious question: How to get the most out of these cores?

One solution is through parallel programming, which is executing multiple tasks at the same time to fully utilize the CPU cores. This is a unique thing about Go language, it is a language designed for concurrent programming.

In this article, we will explore how to use the Go language for concurrent programming.

Coroutine

First of all, what we need to understand is a special mechanism in the Go language: coroutine. Coroutine is a lightweight thread that can switch execution multiple times in one thread to achieve parallel execution.

Compared with operating system threads, the switching cost of coroutines is very low. They are managed by the Go runtime, which uses an m:n mapping to map m coroutines onto n operating system threads. This makes the Go language very efficient and stable in concurrent execution capabilities.

In the Go language, you can use the go keyword to start a coroutine. For example:

func main() {
    go hello()
}

func hello() {
    fmt.Println("Hello, world!")
}

In the above code, the hello() function will be executed in a new coroutine. When the program exits the main() function, the hello() function may still be executing, so the program will not exit immediately.

Channel

Communication between coroutines is very important because they need to share data. There is a special type of variable in the Go language called a channel, which is used to transfer data between coroutines.

You can create a channel through the make() function, for example:

ch := make(chan int)

The above code will create a channel of integer type.

Data can be passed through the send and receive operations of the channel. Channels can be sent and received using the <- operators. For example:

ch <- 42 // 发送数据
x := <-ch // 接收数据

<- Operators can be used on the left or right side to send or receive data. If the channel is unbuffered, the send operation will block until another coroutine receives the data. Similarly, if no data is available, the receive operation will block.

WaitGroup

When processing multiple coroutines, you may need to wait for them all to complete execution. You can use sync.WaitGroup to achieve this purpose. For example:

func main() {
    var wg sync.WaitGroup
    wg.Add(2) // 增加计数器

    go func() {
        defer wg.Done() // 完成时减少计数器
        fmt.Println("Hello,")
    }()

    go func() {
        defer wg.Done() // 完成时减少计数器
        fmt.Println("world!")
    }()

    wg.Wait() // 等待协程全部完成
}

In the above code, wg is a sync.WaitGroup object that contains a counter. Add() The method increases the counter to indicate the number of coroutines that need to wait. Done() The method decrements the counter to indicate that a coroutine has been completed. Wait() The method will wait until the counter reaches zero.

Example

The following is a sample program that demonstrates how to use coroutines and channels for concurrent programming:

func main() {
    ch := make(chan int)

    go func() {
        for i := 0; i < 10; i++ {
            ch <- i // 发送数据
        }
        close(ch) // 关闭通道
    }()

    for i := range ch { // 循环接收数据，直到通道关闭
        fmt.Println(i)
    }
}

In the above code, we create an integer type Channelch. We then send integers from 0 to 9 to the channel in a new coroutine. Finally, we use the range keyword to loop through the data in the channel and print it out.

Note that after we send all the data, we close the channel through the close() method. This allows the coroutine that loops to read the channel to exit.

Conclusion

In this article, we learned about coroutines, channels and WaitGroup in the Go language. Through these mechanisms, efficient concurrent programming can be easily implemented. When writing Go code, be sure to consider using these mechanisms to fully utilize CPU cores and hardware resources.

The above is the detailed content of How to use Go language for concurrent programming?. For more information, please follow other related articles on the PHP Chinese website!