Go Deeper: Practical Code Demonstrations of Concurrent Programming

In-depth Go language: practical code demonstration of concurrent programming

In today's Internet era, concurrent programming has become an indispensable and important technology in software development. As a programming language with superior concurrency performance, Go language provides rich and powerful concurrent programming features, allowing developers to write efficient concurrent programs more easily. This article will use practical code examples to show how to use concurrent programming in the Go language to improve program performance and efficiency.

1. Concurrency basics

In Go language, we can use goroutine to achieve concurrent execution. Goroutines are similar to threads, but are more lightweight than threads. A Go program can run thousands of goroutines at the same time. The following is a simple goroutine example:

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    for i := 0; i < 5; i++ {
        fmt.Println("Hello")
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    go sayHello()
    time.Sleep(500 * time.Millisecond)
    fmt.Println("Main function")
}

In the above code, we use the go keyword to start a goroutine to execute the sayHello function, and at the same time the main functionmain is also executing. Through goroutine, we can execute different tasks concurrently and improve program performance.

2. Concurrent communication

In concurrent programming, communication is a key part. The Go language provides channel to implement communication between goroutines. The following is an example of using channels for communication:

package main

import (
    "fmt"
)

func produce(ch chan int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)
}

func consume(ch chan int) {
    for num := range ch {
        fmt.Println("Consumed:", num)
    }
}

func main() {
    ch := make(chan int)
    go produce(ch)
    go consume(ch)
    fmt.Scanln()
}

In the above code, we define a channel for communication between producers and consumers. Producers write data to channel, and consumers read data from channel and process it. Safe communication between goroutines can be achieved through channel to avoid the occurrence of race conditions.

3. Concurrency control

In actual development, we may need to control the execution order or number of goroutines. The Go language provides tools such as WaitGroup and Mutex in the sync package to implement concurrency control. The following is an example of using WaitGroup to implement concurrency control:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting
", id)
    fmt.Printf("Worker %d done
", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    wg.Wait()
    fmt.Println("All workers done")
}

In the above code, we use WaitGroup to wait for all goroutines to complete execution. Increase the number of waiting goroutines through the Add method, and the Done method indicates that a goroutine has been executed. Use the Wait method to wait for all goroutines to be executed to ensure the correctness of the program.

Conclusion

Through the above code examples, we have an in-depth understanding of the practical skills of concurrent programming in Go language. Concurrent programming can improve program performance and efficiency, but care must also be taken to avoid concurrency safety issues. I hope this article can be helpful to developers when using Go language for concurrent programming. Let's explore the fun of concurrent programming together!

The above is the detailed content of Go Deeper: Practical Code Demonstrations of Concurrent Programming. For more information, please follow other related articles on the PHP Chinese website!