Parlons de quelques techniques de programmation simultanée Golang couramment utilisées

Golang est un langage de programmation largement utilisé pour créer des programmes efficaces, performants, parallèles et distribués. Il présente l’avantage d’une syntaxe simple et légère tout en permettant d’utiliser facilement la programmation concurrente.

Dans Golang, l'utilisation de goroutines et de canaux pour implémenter la programmation simultanée est un moyen populaire. Goroutine est un thread léger unique à Golang. Il peut exécuter plusieurs tâches en même temps dans un seul thread et peut basculer sans surcharge lorsque les tâches ne sont pas bloquées. Channel est une primitive de synchronisation qui permet à plusieurs goroutines de collaborer pour effectuer le transfert de données et la synchronisation entre les tâches.

Jetons un coup d'œil à quelques techniques de programmation simultanée Golang couramment utilisées :

1. Utilisez goroutine pour obtenir la concurrence

Goroutine dans Golang est très facile à utiliser. Il vous suffit d'ajouter un mot-clé "go" avant l'appel de fonction. changez-le en goroutine. Par exemple :

func main() {
    //启动一个新的goroutine
    go func() {
        fmt.Println("Hello World")
    }()

    //在这里继续执行其他任务
    //...
}

Le code ci-dessus affichera "Hello World" dans un autre thread et la fonction principale continuera à s'exécuter en même temps. L'utilisation de goroutine peut considérablement améliorer la simultanéité et la vitesse de réponse du programme.

2. Utilisez des canaux pour réaliser la synchronisation des données

Le canal de Golang est une primitive de synchronisation utilisée pour transférer des données et synchroniser entre plusieurs goroutines. Le canal peut établir une communication entre deux goroutines. Il dispose de deux manières d'envoyer et de recevoir des messages, bloquant et non bloquant.

Ce qui suit est un exemple simple utilisant des canaux pour transférer des données :

func main() {
    //创建一个整数类型的channel
    ch := make(chan int)

    //启动一个goroutine发送数据
    go func() {
        ch <- 123  //发送数据到channel中
    }()

    //接收刚刚发送的数据
    num := <- ch  //从channel中接收数据
    fmt.Println(num)  //输出：123
}

Dans le code ci-dessus, nous créons d'abord un canal de type entier. Ensuite, une goroutine est lancée pour lui envoyer des données, puis les données sont reçues du canal dans le thread principal et sorties. Les canaux peuvent être utilisés pour transférer et synchroniser des données entre différentes goroutines.

3. Utilisez le package sync pour réaliser la synchronisation

sync est une collection de primitives de synchronisation dans Golang, notamment Mutex, RWMutex, Cond, Once, WaitGroup, etc. Peut être utilisé pour implémenter une synchronisation de niveau supérieur et un contrôle de sécurité des threads.

Mutex est un verrou mutex utilisé pour protéger les ressources partagées. Utilisez la fonction Lock() pour obtenir le mutex avant d'accéder à la section critique, et utilisez la fonction Unlock() pour libérer le verrou une fois l'accès terminé.

Ce qui suit est un exemple de compteur thread-safe implémenté à l'aide de Mutex :

import (
    "fmt"
    "sync"
)

type Counter struct {
    count int
    mu    sync.Mutex
}

func (c *Counter) Increment() {
    //获取互斥锁并增加计数
    c.mu.Lock()
    c.count++
    c.mu.Unlock()
}

func (c *Counter) Count() int {
    //获取互斥锁并返回计数
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    //创建一个计数器
    c := Counter{}

    //启动多个goroutine增加计数
    for i := 0; i < 1000; i++ {
        go c.Increment()
    }

    //等待所有goroutine执行完成
    time.Sleep(time.Second)

    //输出计数器的值
    fmt.Println(c.Count())
}

Dans le code ci-dessus, nous utilisons Mutex pour protéger la ressource partagée du compteur, garantissant ainsi sa sécurité des threads lorsque plusieurs goroutines s'exécutent simultanément.

4. Utilisez le package de contexte pour implémenter le contrôle du délai d'attente

Dans Golang, le contexte est un contexte transitif utilisé pour contrôler le comportement du sous-arbre goroutine (similaire à ThreadLocal en Java).

Le package de contexte fournit certaines fonctions, telles que WithCancel(), WithDeadline(), WithTimeout(), etc., qui peuvent être utilisées pour démarrer la gestion du contexte goroutine. Ces fonctions renvoient un nouvel objet de contexte et une fonction qui peut être appelée pour marquer le contexte comme annulé lorsqu'il doit être annulé. Dans goroutine, vous pouvez utiliser le canal Done() de Context pour obtenir le signal d'annulation.

Ce qui suit est un exemple de contrôle de délai d'attente implémenté à l'aide du contexte :

import (
    "fmt"
    "context"
)

func main() {
    //创建一个带超时的上下文
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)

    //执行一个耗时任务
    go func() {
        time.Sleep(time.Second * 2)
        fmt.Println("Goroutine Done")
    }()

    //等待上下文取消信号
    select {
    case <-ctx.Done():
        fmt.Println("Timeout")
    }

    //取消上下文
    cancel()
}

Dans le code ci-dessus, nous créons d'abord un contexte avec un délai d'attente de 1 seconde, démarrons une goroutine qui prend 2 secondes, puis dans la fonction principale Attendons le Canal Done() du contexte et sortie "Timeout" une fois qu'un signal d'annulation est reçu.

5. Utilisez sync/atomic pour implémenter des opérations atomiques pendant la compétition

Dans Golang, le package sync/atomic fournit certaines fonctions d'opération atomique qui peuvent être utilisées pour mettre à jour les valeurs entières ou de pointeurs partagées pendant la compétition. L'utilisation d'opérations atomiques peut éviter les conditions de concurrence lorsque plusieurs goroutines s'exécutent simultanément.

Ce qui suit est un exemple d'opération atomique implémentée à l'aide du package sync/atomic pour générer un compteur hexadécimal :

import (
    "fmt"
    "sync/atomic"
)

func main() {
    //定义一个uint32的计数器
    var counter uint32

    //启动多个goroutine更新计数器
    for i := 0; i < 1000; i++ {
        go func() {
            //原子地增加计数器
            atomic.AddUint32(&counter, 1)
        }()
    }

    //等待所有goroutine执行完成
    time.Sleep(time.Second)

    //输出计数器的值
    fmt.Printf("0x%x\n", atomic.LoadUint32(&counter))
}

Dans le code ci-dessus, nous définissons un compteur de type uint32 et utilisons la fonction AddUint32() pour l'exécuter simultanément avec plusieurs goroutines Incrémente atomiquement le décompte lors de l’exécution. Enfin, la valeur hexadécimale du compteur est affichée.

Résumé : 

La programmation simultanée dans Golang présente les caractéristiques de simplicité, de légèreté et de hautes performances. Grâce à l'utilisation de fonctions d'outils telles que goroutine, canal et synchronisation, la collaboration et la communication entre les threads peuvent être facilement réalisées, ainsi que la concurrence. les performances du programme peuvent être améliorées et la vitesse de réponse. Dans le même temps, il faut prêter attention à l’utilisation de mécanismes de synchronisation pour éviter les problèmes de sécurité des threads.

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!