How to create parallel tasks using pipelines in Go?

Pipeline is an unbuffered communication mechanism that can be used to create parallel tasks: Create a pipeline: ch := make(chan int) Send data: ch

How to use pipelines in the Go language to create parallel tasks

Pipelines are an unbuffered communication mechanism used in the Go protocol transfer data between processes. Pipes can be used to create parallel tasks to process multiple inputs or outputs simultaneously.

Create a pipe

Use the make function to create a pipe and specify the type of value to be sent or received:

var ch chan int
ch = make(chan int)

Send data

Use the operator to send data to the pipe:

go func() {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
}()

Receive data

Use the operator to receive data from the pipe :

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

Practical Example: Sum

The following example demonstrates how to use pipelines to create parallel tasks to calculate the sum of a bunch of numbers:

package main

import (
    "fmt"
    "time"
)

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

    go func() {
        sum := 0
        for i := 1; i <= 1000000; i++ {
            sum += i
        }
        ch <- sum
    }()

    result := <-ch

    fmt.Println("The sum is:", result)
}

In this example, a The coroutine is responsible for calculating the sum and sending it to the pipeline. The main coroutine receives the results from the pipe and prints them.

This is just a simple example of using pipelines to create parallel tasks. It can be used in various scenarios, such as:

• Multiple coroutines processing data
• Distributed computing
• Event processing

The above is the detailed content of How to create parallel tasks using pipelines in Go?. For more information, please follow other related articles on the PHP Chinese website!