Golang coroutines and concurrency model

Coroutines in Go are a lightweight concurrency mechanism that allow multiple tasks to be executed in the same process. They share process memory space and can communicate through channels. Additionally, the article provides the following: Coroutine creation using the go keyword. Channels are created with the make function and can be used to pass values ​​between coroutines. The practical case demonstrates how to use coroutines to implement parallel computing, and calculate 100,000 prime numbers through 8 coroutines.

Go Coroutines and Concurrency Model

Introduction

Coroutines are Go A lightweight concurrency mechanism in the language that allows multiple independent tasks to run in the same process. This article will explore coroutines and concurrency models in Go and provide practical examples.

Coroutine

Coroutine is a concurrent execution unit in the Go language, similar to a thread, but more lightweight. Coroutines share the memory space of the same process and can easily share data. Create a coroutine using the go keyword, as follows:

go func() {
    // 协程体
}

Channel

Channel is a communication mechanism in Go, used to pass between coroutines value. Channels can be unidirectional or bidirectional, and can be buffered or unbuffered. Create a channel using the make function, as shown below:

ch := make(chan int, 10)

Practical Case: Parallel Computing

Let us use coroutines to implement a practical case of parallel computing. We create a coroutine pool and calculate a large prime number table in each coroutine:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const primeCount = 100000

// 计算素数
func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

// 协程函数
func parallelPrimes(ch chan int) {
    for i := 0; i < primeCount; i++ {
        n := rand.Intn(100000)
        if isPrime(n) {
            ch <- n
        }
    }
}

func main() {
    // 创建通道和协程池
    ch := make(chan int, primeCount)
    for i := 0; i < 8; i++ {
        go parallelPrimes(ch)
    }

    // 等待协程池完成
    close(ch)

    start := time.Now()
    // 收集素数
    for prime := range ch {
        fmt.Println(prime)
    }
    elapsed := time.Since(start)
    fmt.Printf("Elapsed time: %v\n", elapsed)
}

In this case, we created 8 coroutines, each coroutine is responsible for calculating 100,000 prime numbers . The main coroutine is responsible for collecting prime numbers and printing them to the console.

The above is the detailed content of Golang coroutines and concurrency model. For more information, please follow other related articles on the PHP Chinese website!