Goroutine inter-process communication and synchronization techniques for Golang functions

In Golang, goroutine is a lightweight thread with powerful concurrent processing capabilities. Function is the basic programming structure in Golang. It is widely used in development and is also an important tool for communication and synchronization between goroutines. This article will introduce some goroutine inter-process communication and synchronization techniques for Golang functions to help Golang developers better apply these technologies.

1. Channel

Channel is one of the basic tools in Golang concurrent programming. It can be used for communication and synchronization between goroutines. A channel is created by make and has a type and capacity. The capacity of a channel indicates the amount of data it can buffer. If the capacity is 0, it means it is an unbuffered channel and can only be used for synchronization purposes.

The use of Golang channels is very simple, just use the

ch := make(chan int, 10) // 创建具有10个缓冲区的通道

go func(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch) // 关闭通道
}(ch)

for value := range ch {
    fmt.Println(value)
}

The above code creates a channel with 10 buffers, then starts a goroutine to send values ​​from 0 to 9 to the channel, and closes the channel after the sending is completed. Then use range to traverse the channel and continuously read data from it until the channel is closed.

2. Mutex lock (mutex)

In Golang, a variable may be accessed by multiple goroutines at the same time, causing a race condition. To avoid this, we need to use a mutex to protect shared variables. Mutex is a synchronization mechanism in Golang, which can be used to ensure that only one goroutine can access shared resources at any time.

Golang’s mutex lock is implemented in the sync package, and its use is also very simple. You only need to call the Lock() and Unlock() methods. For example:

var counter int
var mutex sync.Mutex

func main() {
    for i := 0; i < 10; i++ {
        go func() {
            for j := 0; j < 100; j++ {
                mutex.Lock() // 加锁
                counter++
                mutex.Unlock() // 解锁
            }
        }()
    }

    time.Sleep(time.Second)
    fmt.Println(counter)
}

The above code starts 10 goroutines, and each goroutine will perform counter operations 100 times. Use a mutex to protect the counter variable to ensure that only one goroutine can modify it at a time. Use the time.Sleep function to wait for all goroutines to finish executing, and finally print out the value of counter.

3. Condition variable (cond)

Condition variable is a synchronization mechanism in Golang. It is used together with a mutex lock and can be used to wait for certain events to occur, or to wait Availability of certain resources. Condition variables can be used to coordinate synchronization operations between multiple goroutines, which allow goroutines to wait for a certain condition to be true before continuing execution.

Golang’s condition variables are implemented in the sync package, and their use is also very simple. You only need to call the Wait(), Signal() and Broadcast() methods. For example:

var (
    mutex sync.Mutex
    cond  *sync.Cond
)

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

func consumer(ch <-chan int) {
    for {
        mutex.Lock()
        if len(ch) == 0 {
            cond.Wait() // 等待条件变量
        }
        value := <-ch
        fmt.Println(value)
        mutex.Unlock()
    }
}

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

    mutex.Lock()
    cond = sync.NewCond(&mutex)
    go producer(ch)
    go consumer(ch)
    mutex.Unlock()

    time.Sleep(time.Second)
    mutex.Lock()
    cond.Signal() // 唤醒一个等待的goroutine
    mutex.Unlock()
}

The above code creates a channel with a buffer, and then starts a producer goroutine and a consumer goroutine. The consumer goroutine reads one value from the channel each time and outputs it. If the channel is empty, the consumer goroutine will call the Wait() method of the condition variable and then wait to be awakened. The producer goroutine will continuously write data to the channel. When the data is written, it will call the Signal() method of the condition variable to wake up the waiting goroutine.

Summary

In Golang, function is an important programming structure, which can be used for communication and synchronization between goroutines. Channels, mutexes, and condition variables are commonly used Golang functions for goroutine inter-process communication and synchronization techniques. They provide rich concurrency mechanisms and can help us better manage goroutine behavior. At the same time, we also need to pay attention to the issues involved in concurrent programming, such as race conditions, deadlocks, etc., to ensure the correctness and efficiency of the program.

The above is the detailed content of Goroutine inter-process communication and synchronization techniques for Golang functions. For more information, please follow other related articles on the PHP Chinese website!