Comment gérer les problèmes de sécurité de concurrence dans le langage Go ?-Golang-php.cn

Comment gérer les problèmes de sécurité de concurrence dans le langage Go ?

WBOY

Libérer： 2023-10-09 10:15:11

original

1140 Les gens l'ont consulté

Comment gérer les problèmes de sécurité de concurrence dans le langage Go ?

Comment gérer les problèmes de sécurité de concurrence en langage Go ?

Le langage Go est un langage spécialement conçu pour gérer la programmation simultanée, il présente donc de forts avantages pour traiter les problèmes de sécurité de la concurrence. Dans le cas de plusieurs goroutines accédant et modifiant des données partagées en même temps, si des mesures appropriées ne sont pas prises pour garantir la sécurité de la concurrence, des erreurs inattendues et des courses de données en résulteront. Cet article présentera en détail comment gérer les problèmes de sécurité de concurrence dans le langage Go et donnera quelques exemples de code.

Verrouillage Mutex
Le verrouillage Mutex est l'une des méthodes de contrôle de concurrence les plus couramment utilisées. Il peut garantir qu'un seul goroutine peut accéder à la section critique en même temps. Dans le langage Go, les verrous mutex sont implémentés à l'aide du type Mutex fourni par le package de synchronisation. Voici un exemple de code qui utilise un verrou mutex pour garantir la sécurité de la concurrence :

package main

import (
    "fmt"
    "sync"
)

var (
    count int
    mutex sync.Mutex
)

func main() {
    wg := sync.WaitGroup{}
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("Count:", count)
}

func increment(wg *sync.WaitGroup) {
    mutex.Lock()
    defer mutex.Unlock()
    count++
    wg.Done()
}

Copier après la connexion

Dans l'exemple de code ci-dessus, une variable globale count est utilisée pour représenter un compteur, qui est contrôlé par plusieurs goroutines. en même temps, effectuez des opérations d'incrémentation. Afin de garantir la sécurité de la concurrence, nous utilisons un mutex pour verrouiller la section critique afin de garantir qu'une seule goroutine puisse accéder et modifier le compteur à la fois. Enfin, nous utilisons WaitGroup du package sync pour attendre la fin de toutes les goroutines et imprimer la valeur finale du compteur. count来表示一个计数器，多个goroutine同时对其进行递增操作。为了保证并发安全，我们使用互斥锁来锁定临界区，确保每次只有一个goroutine可以访问和修改计数器。最后，我们使用sync包中的WaitGroup等待所有goroutine完成，并打印出计数器的最终值。

读写互斥锁
有时候在并发程序中，读操作可以同时进行，而写操作需要互斥进行。为了提高并发性能，我们可以使用读写互斥锁。在Go语言中，使用sync包提供的RWMutex类型来实现读写互斥锁。下面是一个示例代码：

package main

import (
    "fmt"
    "sync"
)

var (
    count int
    mutex sync.RWMutex
)

func main() {
    wg := sync.WaitGroup{}
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go read(&wg)
    }
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go write(&wg)
    }
    wg.Wait()
    fmt.Println("Count:", count)
}

func read(wg *sync.WaitGroup) {
    mutex.RLock()
    defer mutex.RUnlock()
    fmt.Println("Read:", count)
    wg.Done()
}

func write(wg *sync.WaitGroup) {
    mutex.Lock()
    defer mutex.Unlock()
    count++
    fmt.Println("Write:", count)
    wg.Done()
}

Copier après la connexion

在上面的示例代码中，使用了一个全局变量count

Parfois dans les programmes concurrents, les opérations de lecture peuvent être effectuées en même temps, tandis que les opérations d'écriture doivent s'exclure mutuellement. Pour améliorer les performances de concurrence, nous pouvons utiliser des mutex en lecture-écriture. Dans le langage Go, le type RWMutex fourni par le package de synchronisation est utilisé pour implémenter un mutex en lecture-écriture. Voici un exemple de code :

rrreee

count

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!