How to use Goroutines for parallel computing in Go

How to use Goroutines for parallel computing in Go

Overview:
The Go language is a concurrent programming language that natively supports parallel computing. Go provides Goroutines and Channels to implement parallel computing. This article will introduce how to use Goroutines for parallel computing in Go and provide some code examples.

Goroutines:
Goroutine is a lightweight thread in the Go language that can be created and destroyed while the program is running, and the cost of creation, destruction and switching is very low. By using Goroutines, we can implement efficient parallel computing in our programs.

The steps to use Goroutines for parallel computing are as follows:

1. Create Goroutine:
   In the Go language, you can create a Goroutine by using the keyword go, which will need to be executed in parallel. The code is put into this Goroutine.

Code Example:

package main

import (
    "fmt"
    "sync"
)

func calculate(num int, wg *sync.WaitGroup) {
    defer wg.Done()

    result := num * 2
    fmt.Println(result)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go calculate(i, &wg)
    }

    wg.Wait()
}

In the above example, we have created a function called calculate that takes an integer and prints it out by multiplying it by 2. In the main function, we create 10 Goroutines using a loop and pass each number as a parameter to the calculate function. We use the WaitGroup in the sync package to ensure that all Goroutines are executed.

2. Use Channels to transfer data:
   Channels can be used to transfer data between Goroutines. By creating a Channel and using the arrow operator <- to send and receive data to the Channel.

Code example:

package main

import (
    "fmt"
    "sync"
)

func calculate(num int, wg *sync.WaitGroup, result chan<- int) {
    defer wg.Done()

    result <- num * 2
}

func main() {
    var wg sync.WaitGroup
    result := make(chan int)

    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go calculate(i, &wg, result)
    }

    go func() {
        wg.Wait()
        close(result)
    }()

    for res := range result {
        fmt.Println(res)
    }
}

In the above example, we send the result of the calculate function through the result Channel. In the main function, we use an anonymous function to wait for all Goroutines to finish executing and close the result Channel. Finally, we receive the results in the result Channel and print them out by using range in the for loop.

Summary:
By using Goroutines and Channels, we can achieve efficient parallel computing in the Go language. Goroutines can be used to easily create and destroy concurrent computing tasks, and Channels can be used to transfer data conveniently. In practical applications, we can create different numbers of Goroutines as needed and select an appropriate parallel computing model based on the characteristics of the computing task.

The above is an introduction and sample code on how to use Goroutines for parallel computing in Go. I hope this article will help you understand concurrent programming in Go language.

The above is the detailed content of How to use Goroutines for parallel computing in Go. For more information, please follow other related articles on the PHP Chinese website!