Pourquoi un blocage se produit-il lorsque l'appel de fonction qui remplit le canal n'est pas intégré dans un Goroutine ?

Lorsque l'appel de fonction qui remplit le canal n'est pas intégré dans une Goroutine, la raison pour laquelle un blocage se produit est que les opérations d'envoi et de réception du canal sont bloquantes. Si la fonction qui remplit le canal est appelée dans le Goroutine principal et que l'opération de remplissage n'est pas placée dans un nouveau Goroutine pour s'exécuter à l'intérieur de la fonction, alors le Goroutine principal attendra que le canal ait suffisamment d'espace pour recevoir des données, et le L'opération de remplissage ne peut pas être effectuée, ce qui conduit à une impasse. Par conséquent, afin d'éviter une impasse, nous devons utiliser Goroutine pour une exécution simultanée dans l'opération de remplissage du canal afin de garantir que l'opération de remplissage et l'opération de réception peuvent être effectuées en même temps.

Contenu de la question

Je connais l'option sync 包及其 waitgroup et je ne souhaite pas l'utiliser pour ce test. Je teste un sémaphore.

J'ai donc :

package main

import (
    "fmt"
    "os"
    "time"
)

func main() {

    fmt.print("wassap")

    jobs := make(chan int)
    processstarted := make(chan struct{}, 1)
    processcompleted := make(chan struct{}, 1)

    createjobs(jobs)

    go func() {
        worker(jobs, processstarted, processcompleted)
    }()

    go func() {
        sync(processstarted, processcompleted)
    }()

    time.sleep(3600 * time.second)
    fmt.print("\nend of main...")

    interrupt := make(chan os.signal)
    <-interrupt

}

func createjobs(jobs chan<- int) {
    defer close(jobs)
    for i := 1; i < 20; i++ {
        jobs <- i
    }
}

func worker(jobs <-chan int, processstarted <-chan struct{}, processcompleted <-chan struct{}) {

    for {
        select {
        case i := <-jobs:
            fmt.printf("\nfetching job #%d from channel", i)
            time.sleep(2 * time.second)
        case <-processstarted:
            fmt.print("\nprocess started. waiting for it to be completed")
            <-processcompleted
            fmt.print("\nprocess completed")
        }

    }
}

func sync(processstarted chan<- struct{}, processcompleted chan<- struct{}) {

    // acquire semaphore. send signal to channel to indicate that it is busy
    processstarted <- struct{}{}

    for i := 1; i < 5; i++ {
        fmt.printf("\nprocessing %d", i)
        time.sleep(5 * time.second)
    }

    // release semaphore
    processcompleted <- struct{}{}
}

Ce que je veux tester est très simple : j'ai un createjobs 函数，其唯一目的是将元素添加到通道，在本例中是一个 int 通道。然后我有一个 worker qui va extraire un objet de ce canal et dormir pendant 2 secondes avant d'extraire l'élément suivant.

Maintenant, il existe également une fonction de synchronisation. Le seul but de cette fonction est de simuler l'élément worker 运行时启动的进程。如果此进程处于活动状态，则在 sync 结束时应停止处理 jobs, c'est pourquoi j'ai deux canaux, l'un indiquant que le processus a été démarré et l'autre que le processus est terminé.

J'obtiens l'erreur suivante lors de l'exécution de mon code :

fatal error: all goroutines are asleep - deadlock!

Si je modifie la façon dont createjobs est appelé, enveloppez-le dans une goroutine comme ceci :

go func() {
        createJobs(jobs)
    }()

Ensuite, mon code fonctionne correctement.

Je veux juste comprendre pourquoi cela se produit. Ce que je veux dire, c'est : la routine main est en cours d'exécution, puis elle appelle main 例程正在执行，然后它调用 createjobs （无换行），因此 main 例程应该被阻止，直到此调用结束。一旦 createjobs 结束，就说明通道中有元素了。 main 继续执行并启动其他 goroutine worker 和 sync 来完成它们的工作。在 main (sans nouvelle ligne), donc la routine main doit être bloquée jusqu'à la fin de cet appel. Une fois que

se termine, cela signifie qu'il y a un élément dans la chaîne. main continue l'exécution et démarre d'autres goroutines worker et sync pour terminer leur travail. Avant la fin de main, j'ajoute simplement un dormeur pour donner au goroutine précédemment créé le temps de se terminer.

createjobs 发生在 goroutine 之外时会发生什么。

解决方法

您将 jobs 声明为无缓冲通道，然后尝试将 20 个值同步推入其中。当您调用 createjobs(jobs)Je ne demande pas d'autres solutions à ce problème, je veux juste savoir ce qui se passe lorsque

se produit en dehors d'une goroutine.

Solution de contournement

Vous déclarez jobs comme canal sans tampon, puis essayez d'y insérer 20 valeurs de manière synchrone. Cela bloquera votre fonction principale lorsque vous appellerez

. Changez la ligne 13 par :

    jobs := make(chan int, 20)

... résoudra l'impasse.

EDIT - Clarification demandée en commentaires :

createjobs(jobs)

Les canaux non tamponnés n'ont aucune capacité et bloquent l'exécution du producteur jusqu'à ce que le consommateur reçoive le message.

Une bonne analogie pour un canal non tamponné est un tuyau, dans ce cas, le processus ressemble à ceci :

+------------------+     +------------+      +-------------+
| PRODUCER         |     | PIPE       |      | CONSUMER    |
|                  +---->|            +----->|             |
| createJobs(jobs) |     | unbuffered |      | worker(...) |
|                  |     | channel    |      |             |
+------------------+     +------------+      +-------------+

Le blocage se produit parce que

est appelé de manière synchrone et qu'aucun consommateur n'est encore en cours d'exécution. main()

Cela fonctionne lors de l'appel d'une fonction (🎜producteur🎜) dans une goroutine car, en gros, l'insertion du canal et la lecture du canal se font en parallèle ? 🎜 🎜Oui. Si le producteur est appelé de manière asynchrone, cela ne bloquera pas la fonction 🎜, donc le consommateur aura également une chance d'être appelé. Dans ce cas, le producteur va pousser toutes ses tâches une à une, tout comme les ouvriers les consomment une à une. 🎜

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!