Quel est le mécanisme d’interaction entre les fonctions golang et goroutine ?

Function et Goroutine interagissent via les mécanismes suivants dans le langage Go : Channel : échange sécurisé de données entre Goroutines Pipe : utilisé pour communiquer avec des processus externes

Les fonctions dans le langage Go interagissent avec le mécanisme Goroutine

Introduction à Goroutine

Goroutine est un thread léger qui permet aux programmes Go d'exécuter du code en parallèle. Il est géré par Go Runtime et est utilisé pour traiter des tâches en parallèle sans avoir besoin de créer et de gérer manuellement des threads.

Interaction entre les fonctions et les Goroutines

L'interaction entre les fonctions et les Goroutines dans le langage Go est réalisée grâce au mécanisme suivant :

• Channel (Channel) : Un mécanisme de communication pour échanger en toute sécurité des données entre les Goroutines. Il s'agit d'une file d'attente typée dans laquelle l'expéditeur écrit des données sur le canal et le récepteur en lit les données.
• Pipe : Un type spécial de canal conçu pour communiquer avec des outils de ligne de commande ou d'autres processus externes.

Cas pratique : Sommation parallèle

Pour démontrer l'interaction entre la fonction et Goroutine, nous créons un programme de sommation parallèle simple :

package main

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

const numIterations = 1000000

func main() {
    sum := 0

    // 初始化互斥锁以保护并发的 sum 变量
    lock := &sync.Mutex{}

    // 创建一个通道
    c := make(chan int)

    // 创建 Goroutine 并发计算和并将结果发送到通道
    for i := 0; i < numIterations; i++ {
        go func(num int) {
            rand.Seed(time.Now().UnixNano())
            time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
            lock.Lock()
            defer lock.Unlock()
            sum += num
            c <- num
        }(i)
    }

    // 从通道接收数据并打印进度条
    for i := 0; i < numIterations; i++ {
        <-c
        fmt.Printf("\rProgress: %f％", float64(i)/float64(numIterations)*100)
    }

    // 等待所有 Goroutine 完成
    time.Sleep(time.Second)

    fmt.Println("\nFinal sum:", sum)
}

Dans ce programme, nous utilisons des tuyaux et des verrous mutex pour implémenter la connexion entre la fonction et Goroutine Interaction :

• Un mutex protège les variables accessibles simultanément sum pour garantir l'intégrité des données.
• Goroutine envoie le résultat de la sommation au pipeline.
• La fonction principale lit les résultats du tuyau et imprime la barre de progression.

Grâce à ce mécanisme, Goroutine peut exécuter la tâche de sommation simultanément, et la fonction principale peut suivre la progression et collecter le résultat final.

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!