Comment golang simultanément

Dans le développement de logiciels modernes, la programmation simultanée est devenue l'une des compétences nécessaires. Le langage Go est un langage spécialement conçu pour la programmation simultanée. Ses Goroutines, canaux, Mutex et autres mécanismes intégrés peuvent grandement simplifier la complexité de la programmation simultanée. Cet article explique comment effectuer une programmation simultanée dans le langage Go, vous fournissant des connaissances de base et des compétences pratiques afin que vous puissiez écrire des programmes simultanés plus efficacement.

1. Qu'est-ce que la programmation simultanée

Habituellement, nous avons plusieurs tâches à traiter dans le logiciel, comme lire plusieurs fichiers en même temps ou lire à partir de plusieurs bases de données Obtenir des données depuis. La programmation simultanée consiste à exécuter plusieurs parties du programme en même temps pour améliorer l'efficacité du programme dans le traitement des tâches. En programmation simultanée, nous devons éviter les conflits entre plusieurs tâches et garantir l’exactitude et la maintenabilité du code.

2. Goroutines et canaux

Les Goroutines et les canaux en langage Go sont les mécanismes de base pour la mise en œuvre de la programmation simultanée.

Les Goroutines sont des threads légers dans le langage Go. Démarrer une nouvelle Goroutine via le mot-clé go permet au programme d'effectuer plusieurs tâches en même temps. Goroutine peut s'exécuter dans le même espace d'adressage et peut facilement changer de thread sans avoir à créer de threads, à détruire des threads et à changer de contexte comme les threads du système d'exploitation.

Channel est un moyen de messagerie entre Goroutines dans le langage Go. Grâce aux canaux, les Goroutines peuvent échanger des données en toute sécurité et éviter les courses aux données. Le canal peut être considéré comme un canal qui envoie des messages (données) dans un Goroutine et reçoit des messages (données) dans un autre Goroutine, réalisant ainsi la communication entre deux Goroutines.

Ce qui suit est un exemple simple utilisant des Goroutines et des canaux pour implémenter des calculs simultanés :

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()
    c := make(chan int)
    go calculateSum(c)
    sum := <-c
    end := time.Now()
    fmt.Printf("Sum: %v
Time: %v", sum, end.Sub(start))
}

func calculateSum(c chan int) {
    sum := 0
    for i := 0; i < 1000000000; i++ {
        sum += i
    }
    c <- sum
}

Dans cet exemple, nous démarrons une nouvelle Goroutine et calculons de 0 à 1 la somme cumulée de milliards, et le résultat est transmis au principal Goroutine via la Manche. En utilisant Goroutines et Channels, nous pouvons effectuer d'autres tâches pendant le processus de calcul et améliorer l'efficacité du programme.

3. Mutex

En programmation simultanée, nous devons contrôler l'accès aux ressources partagées pour éviter la concurrence des données et les erreurs. Le langage Go fournit Mutex (verrouillage mutex) pour mettre en œuvre un contrôle d'accès sécurisé aux ressources partagées. Mutex peut garantir qu'un seul Goroutine peut accéder aux ressources partagées en même temps, et les autres Goroutines doivent attendre que le Mutex soit déverrouillé avant de pouvoir continuer à y accéder.

Ce qui suit est un exemple d'utilisation de Mutex pour garantir un accès sécurisé aux variables partagées :

package main

import (
    "fmt"
    "sync"
)

var count int
var wg sync.WaitGroup
var mutex sync.Mutex

func main() {
    wg.Add(2)
    go increment()
    go increment()
    wg.Wait()
    fmt.Println("Count:", count)
}

func increment() {
    defer wg.Done()
    for i := 0; i < 1000000; i++ {
        mutex.Lock()
        count++
        mutex.Unlock()
    }
}

Dans cet exemple, nous démarrons deux Goroutines pour effectuer des opérations sur la variable de nombre partagé 1 millions d’opérations supplémentaires. Avant que chaque Goroutine n'incrémente la variable count, nous utilisons un Mutex pour verrouiller la variable afin de garantir qu'un seul Goroutine peut accéder à la variable en même temps.

4. Utilisez des sémaphores pour contrôler la concurrence

En plus d'utiliser Mutex pour contrôler l'accès aux ressources partagées, nous pouvons également utiliser des sémaphores pour contrôler la concurrence afin d'éviter une concurrence excessive dans le système Et s'effondrer.

Semaphore est une technologie de programmation concurrente classique dans le système d'exploitation. Elle permet de contrôler le nombre de ressources partagées accessibles en même temps, contrairement à Mutex qui n'a qu'un seul Goroutine accessible à tout moment. Le package de synchronisation dans le langage Go prend en charge les sémaphores, qui peuvent facilement contrôler le nombre de Goroutines simultanées.

Ce qui suit est un exemple d'utilisation d'un sémaphore pour contrôler le nombre de simultanéités Goroutine :

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup
var semaphore = make(chan struct{}, 2) // 最多允许2个Goroutine并发访问

func main() {
    for i := 0; i < 5; i++ { // 开启5个任务
        wg.Add(1)
        go runTask(i)
    }
    wg.Wait()
}

func runTask(i int) {
    defer wg.Done()
    semaphore <- struct{}{} // 加锁，占用1个slot
    defer func() {
        <-semaphore // 解锁，释放1个slot
    }()

    fmt.Printf("Task %d start
", i)
    // do something
    fmt.Printf("Task %d end
", i)
}

Dans cet exemple, nous utilisons un Channel d'une capacité de 2 comme sémaphore , ce qui peut être autorisé. Jusqu'à 2 Goroutines peuvent s'exécuter en même temps. Chaque Goroutine obtient un emplacement de sémaphore lors du démarrage d'une tâche et libère le sémaphore après avoir terminé la tâche. Lorsqu'il y a déjà deux Goroutines en cours d'exécution, les Goroutines suivantes doivent attendre que les tâches existantes soient terminées et libérer le sémaphore avant de pouvoir commencer à s'exécuter.

En utilisant des sémaphores, nous pouvons contrôler efficacement le nombre de tâches simultanées et éviter une pénurie de ressources ou un crash causé par une concurrence excessive du système.

5. Résumé

La programmation simultanée est une compétence essentielle dans le développement de logiciels modernes. Le langage Go fournit des mécanismes Goroutines et Channels simples et faciles à utiliser, ainsi que Mutex et. des sémaphores et d'autres mécanismes avancés pour nous permettre de réaliser une programmation simultanée efficace et sûre. Lors de l'utilisation de ces mécanismes, nous devons prêter attention à la gestion de la concurrence des données et des ressources partagées pour garantir l'exactitude et la maintenabilité du programme. Grâce à l'introduction de cet article, vous devriez déjà savoir comment utiliser des mécanismes tels que les Goroutines, les canaux, les Mutex et les sémaphores pour la programmation simultanée, et être capable d'écrire des programmes simultanés efficaces et sûrs.

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!