Comment obtenir en toute sécurité des données partagées dans Goroutine ?

Go peut obtenir en toute sécurité les données partagées des goroutines grâce aux méthodes suivantes : 1. Mutex (Mutex) : permet à une goroutine d'avoir un accès exclusif aux données partagées ; 2. Channel (Channel) : coordonne l'accès aux données partagées et sert de lien entre goroutines Mécanisme de transfert de données ; 3. Opération atomique : lire et modifier atomiquement les variables partagées pour assurer la cohérence des données.

Comment obtenir en toute sécurité des données partagées dans goroutine dans Go ?

En programmation concurrente, la coordination de l'accès aux données partagées est cruciale. Le langage Go propose plusieurs façons d'y parvenir, notamment les mutex, les canaux et les opérations atomiques.

Verrouillage Mutex

Mutex est utilisé pour permettre à une goroutine d'accéder aux données partagées à la fois. Pour créer un mutex, utilisez le type sync.Mutex. Voici un exemple d'utilisation d'un mutex : sync.Mutex 类型。以下是如何使用互斥锁示例：

package main

import (
    "fmt"
    "sync"
)

// 共享变量
var counter int

func main() {
    var mu sync.Mutex

    // 创建 10 个 goroutine，每个 goroutine 增加 counter
    for i := 0; i < 10; i++ {
        go func() {
            mu.Lock()
            defer mu.Unlock()
            counter++
            fmt.Printf("goroutine %d: %d\n", i, counter)
        }()
    }
}

通道

通道可以用来在 goroutine 之间传递数据，也可以用来协调对共享数据的访问。要创建通道，可以使用 make(chan) 函数。以下是如何使用通道示例：

package main

import (
    "fmt"
    "sync"
)

// 共享变量
var counter int

func main() {
    ch := make(chan struct{})

    // 创建 10 个 goroutine，每个 goroutine 增加 counter
    for i := 0; i < 10; i++ {
        go func() {
            defer close(ch)

            for {
                select {
                case <-ch:
                    return
                default:
                    counter++
                    fmt.Printf("goroutine %d: %d\n", i, counter)
                }
            }
        }()
    }

    // 等待所有 goroutine 完成
    for i := 0; i < 10; i++ {
        <-ch
    }
}

原子操作

原子操作可以用来原子性地读取和修改共享变量的值。Go 语言提供了 sync/atomic

package main

import (
    "fmt"
    "sync/atomic"
)

// 共享变量
var counter int

func main() {
    // 使用 AddInt64 增加 counter
    for i := 0; i < 10; i++ {
        go func() {
            atomic.AddInt64(&counter, 1)
            fmt.Printf("goroutine %d: %d\n", i, counter)
        }()
    }
}

Channels

🎜🎜Les canaux peuvent être utilisés pour transmettre des données entre goroutines et peuvent également être utilisés pour coordonner l'accès aux données partagées. Pour créer une chaîne, utilisez la fonction make(chan). Voici un exemple d'utilisation des canaux : 🎜rrreee🎜🎜Opérations atomiques🎜🎜🎜Les opérations atomiques peuvent être utilisées pour lire et modifier atomiquement la valeur d'une variable partagée. Le langage Go fournit le package sync/atomic pour prendre en charge les opérations atomiques. Voici un exemple d'utilisation des opérations atomiques : 🎜rrreee🎜 Parmi ces méthodes, la méthode à choisir dépend du scénario spécifique et du niveau d'assurance de sécurité requis. 🎜

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!