Master multi-threaded programming and concurrency control in Go language

Master multi-threaded programming and concurrency control in Go language

Abstract: This article introduces the basic concepts and usage of multi-threaded programming and concurrency control in Go language. Through the introduction and analysis of usage examples of goroutine and channel in Go language, it can help readers master multi-thread programming and concurrency control skills in Go language to improve program performance and efficiency.

1. Introduction

With the development of computer hardware, multi-core processors have become the mainstream of modern computers. To fully exploit the potential of multi-core processors, developers need to implement concurrency control through multi-threaded programming. However, traditional multi-threaded programming methods often cause a series of problems, such as deadlocks, race conditions, etc. In order to solve these problems, the Go language provides a simple and powerful multi-threaded programming and concurrency control method.

2. Basic concepts of Goroutine and channel

The goroutine in the Go language is a lightweight thread that can execute tasks concurrently in the program. Compared with traditional threads, goroutine has very little startup and destruction overhead and can efficiently achieve large-scale concurrency. In the Go language, you can start a goroutine through the keyword go, for example:

go func() {
    // 任务代码
}()

channel is a communication mechanism used to transmit data between goroutines. A channel can be thought of as a pipe through which a goroutine can send and receive data. In the Go language, you can use the keyword make to create a channel, for example:

ch := make(chan int)

3. Goroutine usage example

The following is a simple example to illustrate how to use it goroutine for concurrent programming. Suppose there is a function that calculates prime numbers. Parallel calculations can be performed in the following way:

func isPrime(n int) bool {
    if n < 2 {
        return false
    }
    for i := 2; i * i <= n; i++ {
        if n % i == 0 {
            return false
        }
    }
    return true
}

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

    for i := 2; i <= num; i++ {
        go func(n int) {
            if isPrime(n) {
                ch <- n
            }
        }(i)
    }

    for i := 2; i <= num; i++ {
        fmt.Println(<-ch)
    }
}

In the above code, first create a channel ch to receive the calculated prime numbers. Then use a for loop to start multiple goroutines to calculate prime numbers at the same time. After each goroutine completes the calculation, the results are sent to channel ch. Finally, read and print the prime numbers from channel ch through a for loop. By using goroutine, multiple prime numbers can be efficiently calculated simultaneously and the execution efficiency of the program can be improved.

4. Concurrency control

In addition to using goroutine to implement concurrent programming, the Go language also provides some mechanisms for concurrency control. For example, you can use the Mutex type in the sync keyword to implement a mutex lock to protect access to shared resources. An example is as follows:

import "sync"

var count int
var mutex sync.Mutex

func increment() {
    mutex.Lock()
    count++
    mutex.Unlock()
}

func main() {
    var wg sync.WaitGroup
    num := 100

    wg.Add(num)
    for i := 0; i < num; i++ {
        go func() {
            defer wg.Done()
            increment()
        }()
    }

    wg.Wait()
    fmt.Println(count)
}

In the above code, a shared variable count and a mutex lock mutex are first defined. Then use multiple goroutines to call the increment function concurrently, which uses a mutex to protect count access. Finally, WaitGroup is used to wait for all goroutines to be executed and print the result of the count. By using mutex locks, you can ensure that access to shared resources is safe and avoid race conditions.

5. Summary

This article introduces the basic concepts and usage of multi-threaded programming and concurrency control in Go language. Through the introduction and analysis of usage examples of goroutine and channel in Go language, it can help readers master multi-thread programming and concurrency control skills in Go language to improve program performance and efficiency. At the same time, it also introduces the use of concurrency control mechanisms such as mutex locks to ensure safe access to shared resources. Mastering the multi-threaded programming and concurrency control of the Go language will be very helpful in developing high-performance, high-concurrency applications.

The above is the detailed content of Master multi-threaded programming and concurrency control in Go language. For more information, please follow other related articles on the PHP Chinese website!