Concurrent programming and coroutine use in Go language

As a powerful programming language, Go language is famous for its simplicity and efficiency. Among them, its powerful concurrent programming and use of coroutines is one of its biggest highlights. This article will introduce the principles and specific usage of concurrent programming and coroutines in Go language, and provide some code examples to help readers better understand.

1. Concurrent programming

In the Go language, concurrent programming is achieved through goroutine, which can be understood as a lightweight thread. Compared with traditional threads, goroutines have less creation and scheduling overhead and therefore can better support concurrent programming.

1. Create and start goroutine

In Go language, use the go keyword to create and start goroutine. The example is as follows:

package main

import (
    "fmt"
    "time"
)

func printNumber(n int) {
    for i := 0; i < n; i++ {
        fmt.Println(i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go printNumber(5)
    time.Sleep(time.Second * 3)
    fmt.Println("Main goroutine exits")
}

In In the above example, go printNumber(5) creates a goroutine to print numbers from 0 to 4, while the main goroutine continues to execute and exits after 3 seconds. This achieves concurrent execution.

2. Use channels for communication between goroutines

In concurrent programming, communication between goroutines is usually required. The Go language provides channels to implement communication between goroutines.

package main

import (
    "fmt"
)

func sendMessages(messages chan string) {
    messages <- "Hello"
    messages <- "World"
    close(messages)
}

func main() {
    messages := make(chan string)
    go sendMessages(messages)

    for msg := range messages {
        fmt.Println(msg)
    }
}

In the above example, communication between sendMessages and the main goroutine is achieved through the channel messages. Among them, close(messages) is used to close the channel to avoid deadlock.

2. The use of coroutine

In Go language, coroutine is a lightweight thread, which can be regarded as a user-mode thread. It is controlled by the user program. control. Coroutines in the Go language are called goroutines, which are created and started through the go keyword. Coroutines can achieve fast switching of tasks and efficient concurrent execution.

1. Example of using coroutine

package main

import (
    "fmt"
)

func add(a, b int, result chan int) {
    sum := a + b
    result <- sum
}

func main() {
    result := make(chan int)
    go add(2, 3, result)

    sum := <-result
    fmt.Println("Sum:", sum)
}

In the above example, a goroutine is created to calculate the sum of 2 by go add(2, 3, result) The sum of 3 realizes the transmission of the result through channel result.

Conclusion

This article introduces the use of concurrent programming and coroutines in the Go language, and provides some sample code to help readers understand. Concurrent programming and coroutines are one of the most powerful features of the Go language, which can effectively improve the performance and efficiency of the program. I hope this article will be helpful to readers in learning and using concurrent programming and coroutines in Go language.

The above is the detailed content of Concurrent programming and coroutine use in Go language. For more information, please follow other related articles on the PHP Chinese website!