Go programmation concurrente : utilisation de canaux et de primitives de synchronisation

En résumé, les canaux et les primitives de synchronisation dans Go sont des outils cruciaux en programmation simultanée. Les canaux sont utilisés pour échanger des données en toute sécurité, tandis que les primitives de synchronisation sont utilisées pour contrôler l'exécution simultanée des Goroutines. Plus précisément, les canaux permettent aux Goroutines de transmettre des données, les mutex protègent les ressources partagées, les variables de condition attendent que les conditions soient vraies et les événements sont utilisés pour synchroniser les Goroutines. En utilisant ces mécanismes, les développeurs peuvent créer des applications simultanées efficaces et évolutives.

Programmation simultanée Go : utilisation des canaux et des primitives de synchronisation

Les canaux et les primitives de synchronisation dans Go sont des outils clés pour la mise en œuvre de la programmation simultanée. Cet article explorera l'utilisation des deux mécanismes et démontrera leur puissance à travers des exemples pratiques.

Channels

Les canaux sont un mécanisme utilisé pour échanger en toute sécurité des données entre Goroutines simultanées. C'est similaire à un tube, les données peuvent être écrites à une extrémité et lues à l'autre extrémité.

// 声明一个用于传递整数的通道
channel := make(chan int)

// 在一个 Goroutine 中写入通道
go func() {
    channel <- 42
}()

// 在另一个 Goroutine 中读取通道
value := <-channel

Primitives de synchronisation

Les primitives de synchronisation sont une série d'outils permettant de contrôler l'exécution simultanée de Goroutine. Ils incluent des éléments tels que des verrous, des mutex, des variables de condition et des événements.

Verrouillage Mutex

Le verrouillage Mutex est utilisé pour garantir qu'un seul Goroutine accède aux ressources partagées en même temps.

// 声明一个互斥锁
var mu sync.Mutex

// 在一个 Goroutine 中使用互斥锁保护共享资源
func incrementCounter() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

Variables conditionnelles

Les variables conditionnelles sont utilisées pour attendre qu'une certaine condition soit vraie. Goroutine peut attendre une variable de condition jusqu'à ce que la condition soit remplie avant de poursuivre l'exécution.

// 声明一个条件变量
var cv sync.Cond

// 在一个 Goroutine 中等待条件
func waitForCondition() {
    cv.L.Lock()
    for !condition {
        cv.Wait()
    }
    cv.L.Unlock()
}

// 在另一个 Goroutine 中唤醒等待条件的 Goroutine
func signalCondition() {
    cv.L.Lock()
    condition = true
    cv.Broadcast()
    cv.L.Unlock()
}

Cas pratique

Utiliser des canaux pour traiter des tâches en parallèle

Un problème de concurrence courant est le traitement parallèle des tâches. Ce problème peut être résolu en créant un ensemble de Goroutines qui calculent les résultats et les mettent dans un canal.

// 生成任务列表
tasks := []func() int{
    func() int { return 1 },
    func() int { return 2 },
    func() int { return 3 },
}

// 创建一个通道来接收结果
results := make(chan int)

// 创建 Goroutine 来计算任务
for _, task := range tasks {
    go func(task func() int) {
        results <- task()
    }(task)
}

// 从通道中接收结果
for i := 0; i < len(tasks); i++ {
    result := <-results
    fmt.Println(result)
}

Utilisez des verrous mutex pour protéger l'état partagé

Un autre problème de concurrence courant est la protection de l'état partagé. Ce problème peut être résolu en utilisant un mutex pour garantir qu'un seul Goroutine accède à l'état partagé en même temps.

// 声明共享状态变量
var sharedState int

// 创建一个互斥锁来保护共享状态
var mu sync.Mutex

// 在一个 Goroutine 中读取共享状态
func readSharedState() int {
    mu.Lock()
    defer mu.Unlock()
    return sharedState
}

// 在另一个 Goroutine 中写共享状态
func writeSharedState(value int) {
    mu.Lock()
    defer mu.Unlock()
    sharedState = value
}

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!