Coroutines Golang et modèle de concurrence

Les coroutines dans Go sont un mécanisme de concurrence léger qui permet d'exécuter plusieurs tâches dans le même processus. Ils partagent l'espace mémoire du processus et peuvent communiquer via des canaux. De plus, l'article fournit les éléments suivants : Création de coroutine à l'aide du mot-clé go. Les canaux sont créés avec la fonction make et peuvent être utilisés pour transmettre des valeurs entre coroutines. Le cas pratique montre comment utiliser les coroutines pour mettre en œuvre le calcul parallèle et calculer 100 000 nombres premiers via 8 coroutines.

Go Coroutines et modèle de concurrence

Introduction

Les coroutines sont un mécanisme de concurrence léger dans le langage Go qui permet d'exécuter plusieurs tâches indépendantes dans le même processus. Cet article explorera les coroutines et les modèles de concurrence dans Go et fournira des exemples pratiques.

Coroutines

Les coroutines sont des unités d'exécution simultanées dans le langage Go, similaires aux threads, mais plus légères. Les coroutines partagent l'espace mémoire du même processus et peuvent facilement partager des données. Créez des coroutines à l'aide du mot-clé go comme suit :

go func() {
    // 协程体
}

Channels

Les canaux sont un mécanisme de communication dans Go qui est utilisé pour transmettre des valeurs entre les coroutines. Les canaux peuvent être unidirectionnels ou bidirectionnels et peuvent être mis en mémoire tampon ou non. Créez un canal à l'aide de la fonction make, comme indiqué ci-dessous :

ch := make(chan int, 10)

Cas pratique : calcul parallèle

Utilisons des coroutines pour implémenter un cas pratique de calcul parallèle. Nous créons un pool de coroutines et calculons une grande table de nombres premiers dans chaque 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)
}

Dans ce cas, nous avons créé 8 coroutines, chacune chargée de calculer 100 000 nombres premiers. La coroutine principale est chargée de collecter les nombres premiers et de les imprimer sur la console.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!