Comment implémenter l'impasse dans Golang ? Comment l'éviter ?

Golang est un langage de programmation efficace, fortement typé et statiquement typé, développé par Google pour résoudre certains problèmes tels que les blocages. Bien qu'il soit très difficile d'implémenter un blocage dans Golang, dans cet article, nous explorerons comment implémenter un blocage à l'aide de Golang.

Qu’est-ce que l’impasse ?

Deadlock fait référence à une situation dans laquelle lorsque plusieurs processus ou threads demandent des ressources, ils s'attendent les uns les autres, empêchant tous les processus ou threads de continuer à s'exécuter. Dans les scénarios à forte concurrence, les problèmes de blocage sont très courants.

Dans Golang, utiliser des canaux pour communiquer entre les coroutines est un moyen très courant. Cependant, si le canal entre les coroutines n’est pas utilisé correctement, cela peut facilement entraîner des problèmes de blocage.

Comment mettre en œuvre une impasse ?

Le code suivant est un exemple simple. Lorsque deux goroutines communiquent entre elles via des canaux, un problème de blocage se produit.

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Start.....")
    ch := make(chan int)
    ch <- 1
    fmt.Println(<-ch)
}

Étant donné que le canal est utilisé pour la communication entre les coroutines, lorsque le canal envoie ou reçoit des données, la coroutine actuelle sera bloquée.

Dans ce code, il y a un canal ch, qui envoie d'abord une donnée 1 au canal, puis reçoit les mêmes données 1 du canal. Cependant, étant donné que l'opération de réception du canal doit attendre l'opération d'envoi du canal, le programme sera bloqué, ce qui entraînera un problème de blocage.

Comment éviter les impasses ?

Pour éviter les problèmes de blocage, vous pouvez généralement les résoudre des manières suivantes :

1. Contrôlez l'ordre d'envoi et de réception des canaux pour vous assurer que les coroutines ne s'attendent pas.
2. Avant d'utiliser la chaîne, déterminez si la chaîne a été fermée. Si le canal a été fermé, n'envoyez pas de données au canal, sinon des problèmes de blocage pourraient facilement survenir.
3. Utilisez l'instruction select pour surveiller plusieurs canaux, afin de pouvoir interroger en continu et éviter le problème de blocage dans l'ensemble du programme en raison de l'attente d'un certain canal.

Ce qui suit est un exemple pour éviter les blocages :

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Start.....")
    ch := make(chan int)
    go func() {
        for {
            select {
            case v := <-ch:
                fmt.Println("Receive value from channel:", v)
            default:
                fmt.Println("No value receive from channel.")
            }
        }
    }()
    ch <- 1
}

Dans ce code, nous utilisons le bloc de sélection pour surveiller le canal ch. S'il y a une valeur dans le canal ch, la valeur dans le canal sera reçue, sinon elle le sera. Afficher l'invite « Aucune valeur reçue du canal ».

De cette façon, le programme ne bloquera pas l'ensemble du programme en raison de l'attente d'une certaine chaîne.

Résumé

Dans Golang, bien qu'il soit difficile de mettre en œuvre un blocage, nous pouvons utiliser les canaux de manière raisonnable, contrôler l'ordre d'envoi et de réception du canal, déterminer si le canal a été fermé et utiliser des instructions de sélection pour surveiller efficacement le canal. problèmes de blocage. Ces compétences sont particulièrement importantes dans les scénarios à forte concurrence. J'espère que les lecteurs pourront maîtriser ces compétences et les appliquer au développement réel.

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!