How to communicate using Golang coroutines?

Coroutines are used to communicate in Go. Channels are a basic mechanism used to send and receive data between coroutines. Coroutines can send data to or receive data from a channel by using the send (<-) and receive (<-) operators. Practical case: Parallel summation, demonstrating the use of coroutines and channels to calculate the sum of numbers in parallel, sending the partial sum to the channel, and then receiving and printing it by the main coroutine.

Use Golang coroutines for communication

In the Go language, coroutines provide a lightweight method of concurrent programming and efficient way. They allow multiple tasks to be executed simultaneously within the context of a single thread, thereby improving application performance. Communication between coroutines is crucial for coordinating tasks and sharing data.

Channels

In Go, channels are a basic mechanism for sending and receiving data between coroutines. A channel is an unbuffered or buffered queue used to deliver values. To create a channel, you can use the following syntax:

ch := make(chan T)

where T is the type of element in the channel.

Send data to the channel

To send data to the channel, you can use the <- operator:

ch <- data

Receive data from the channel

To receive data from the channel, you can use <- Operator:

data := <-ch

Practical case: parallel search and

To demonstrate coroutine communication, let us write a program to sum a set of numbers in parallel using coroutines:

package main

import (
    "fmt"
    "sync"
)

func sum(a []int, ch chan int) {
    sum := 0
    for _, v := range a {
        sum += v
    }
    ch <- sum
}

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    ch := make(chan int)

    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        start := i * 2
        end := start + 2
        wg.Add(1)
        go sum(a[start:end], ch)
    }

    go func() {
        for i := 0; i < 5; i++ {
            total := <-ch
            fmt.Println("Partial sum:", total)
        }
        wg.Done()
    }()

    wg.Wait()
}

In this example, we create 5 coroutines Each coroutine uses channel ch to calculate a partial sum. The main coroutine is responsible for receiving these partial sums and printing them to the console.

The above is the detailed content of How to communicate using Golang coroutines?. For more information, please follow other related articles on the PHP Chinese website!