Comment les fonctions Golang communiquent avec goroutine

Les fonctions et les Goroutines peuvent communiquer des manières suivantes : Verrouillage mutex : utilisé pour protéger les ressources partagées Variable de condition : utilisée pour notifier Goroutine qui remplit la condition Canal : tampon de transfert de données Variable atomique : variable d'accès simultané sans verrouillage Cas pratique : traitement parallèle Tâches utilisez Goroutine pour améliorer l'efficacité d'exécution des tâches gourmandes en calcul, qui comprend trois étapes : création de tâches, démarrage des tâches de traitement Goroutine et collecte des résultats de traitement.

La méthode de communication entre les fonctions et les Goroutines en langage Go

En langage Go, les fonctions et les Goroutines peuvent communiquer des manières suivantes :

1. Mutex (Mutex)

Les verrous Mutex sont utilisés pour protégez les ressources partagées et assurez-vous qu’un seul Goroutine peut accéder à la ressource en même temps.

var mu sync.Mutex // 全局互斥锁

func increment(i *int) {
    mu.Lock()
    *i++
    mu.Unlock()
}

2. Variable de condition (Cond)

La variable de condition est utilisée pour avertir le Goroutine en attente lorsque la condition spécifiée est remplie.

var cond sync.Cond // 全局条件变量

func wait(c *sync.Cond, i *int) {
    c.L.Lock()
    for {
        if *i == 0 {
            c.Wait()
        }
        break
    }
    c.L.Unlock()
}

3. Canal

Un canal est un tampon utilisé pour envoyer des données entre Goroutines.

var ch = make(chan int, 10) // 创建容量为 10 的通道

func send(c chan int, i int) {
    c <- i // 发送数据
}

func receive(c chan int) {
    v := <-c // 接收数据
}

4. Variables atomiques

Les variables atomiques sont accessibles simultanément sans verrous.

var atomicInt int64

func incrementAtomic(i *int64) {
    atomicInt++
}

Cas pratique : tâches de traitement parallèles

Ce qui suit est un cas pratique d'utilisation de Goroutine pour traiter des tâches en parallèle :

// 任务类型
type Task struct {
    Num  int
    Chan chan int
}

func processTask(t *Task) {
    // 处理任务并返回结果
    result := t.Num * t.Num
    t.Chan <- result
}

func createTasks(n int) []*Task {
    // 创建 n 个任务
    tasks := make([]*Task, n)
    for i := 0; i < n; i++ {
        tasks[i] = &Task{
            Num:  i,
            Chan: make(chan int),
        }
    }
    return tasks
}

func main() {
    n := 10
    tasks := createTasks(n)

    // 启动 n 个 Goroutine 并行处理任务
    for _, t := range tasks {
        go processTask(t)
    }

    // 从任务中收集处理结果
    results := make([]int, n)
    for i := 0; i < n; i++ {
        results[i] = <-tasks[i].Chan
    }

    // 打印结果
    for _, r := range results {
        fmt.Println(r)
    }
}

Utiliser Goroutine pour traiter des tâches en parallèle peut améliorer considérablement l'efficacité d'exécution du programme, en particulier pour tâches à forte intensité de calcul.

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!