Le traitement parallèle dans golang

Donné le code suivant:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        go f(i)
    }

    //prevent main from exiting immediately
    var input string
    fmt.Scanln(&input)
}

func f(n int) {
    for i := 0; i < 10; i++ {
        dowork(n, i)
        amt := time.Duration(rand.Intn(250))
        time.Sleep(time.Millisecond * amt)
    }
}

func dowork(goroutine, loopindex int) {
    //simulate work
    time.Sleep(time.Second * time.Duration(5))
    fmt.Printf("gr[%d]: i=%d\n", goroutine, loopindex)
}

Puis-je supposer que l '"dowork' fonction sera exécutée en parallèle?

Est-ce une bonne façon de réaliser le parallélisme ou est-il préférable d'utiliser les canaux et séparé dowork " les travailleurs pour chaque goroutine?

  • Juste au cas où quelqu'un trouve ça intéressant: Cet article qui explique comment faire en parallèle pour les boucles en Aller.
  • Grand merci à ce site web se révèle être une ressource fantastique pour moi!
InformationsquelleAutor wilsonfiifi | 2014-08-03
  1. 16

    Votre code sera exécuté simultanément, mais pas en parallèle. Vous pouvez le faire fonctionner en parallèle par la mise en GOMAXPROCS; voir l'article https://www.ardanlabs.com/blog/2014/01/concurrency-goroutines-and-gomaxprocs.html pour un bon résumé.

    Il n'est pas clair exactement ce que vous essayez d'accomplir ici, mais il semble comme un bon moyen de parvenir à la simultanéité de moi.

    • J'ai suivi l'article mentionné ci-dessus exemple. Je ne reçois pas la même sortie. les méthodes se sont exécutées de manière séquentielle pas en parallèle.
    InformationsquelleAutor Evan
  2. 6

    Concernant GOMAXPROCS, vous pouvez trouver ce à Aller de 1,5 libération de docs:

    Par défaut, Allez les programmes s'exécutent avec GOMAXPROCS définir le nombre de cœurs disponibles; dans les versions précédentes il était par défaut 1.

    Concernant la prévention de la main fonction de quitter immédiatement, vous pourriez tirer parti de WaitGroup's Wait fonction.

    J'ai écrit cette fonction d'utilité à l'aide de paralléliser un groupe de fonctions:

    import "sync"

//Parallelize parallelizes the function calls
func Parallelize(functions ...func()) {
    var waitGroup sync.WaitGroup
    waitGroup.Add(len(functions))

    defer waitGroup.Wait()

    for _, function := range functions {
        go func(copy func()) {
            defer waitGroup.Done()
            copy()
        }(function)
    }
}

    Donc dans votre cas, nous pourrions le faire

    func1 := func() {
    f(0)
}

func2 = func() {
    f(1)
}

func3 = func() {
    f(2)
}

Parallelize(func1, func2, func3)

    Si vous voulez utiliser la Parallélisation de la fonction, vous pouvez la trouver ici https://github.com/shomali11/util

    InformationsquelleAutor Raed Shomali
  3. 0

    f() seront exécutées simultanément, mais de nombreux dowork() seront exécutées de façon séquentielle à l'intérieur de chaque f(). En attente sur stdin est pas la bonne façon de s'assurer que vos routines fini de l'exécution. Vous devez faire tourner un canal que chaque f() pousse un true lorsque le f() finitions.
    À la fin de la main() vous devez attendre pour le nombre n de true's sur le canal. n étant le nombre de f() que vous avez lancé.

    • sync.WaitGroup est mieux qu'un canal pour cette affaire.
    InformationsquelleAutor Shantanu Bhadoria
  4. 0

    Cela m'a aidé quand j'ai commencé.

        package main

    import "fmt"

    func put(number chan<- int, count int) {
        i := 0
        for ; i <= (5 * count); i++ {
            number <- i
        }
        number <- -1
    }

    func subs(number chan<- int) {
        i := 10
        for ; i <= 19; i++ {
            number <- i
        }
    }

    func main() {
        channel1 := make(chan int)
        channel2 := make(chan int)
        done := 0
        sum := 0

        go subs(channel2)
        go put(channel1, 1)
        go put(channel1, 2)
        go put(channel1, 3)
        go put(channel1, 4)
        go put(channel1, 5)

        for done != 5 {
            select {
            case elem := <-channel1:
                if elem < 0 {
                    done++
                } else {
                    sum += elem
                    fmt.Println(sum)
                }
            case sub := <-channel2:
                sum -= sub
                fmt.Printf("atimta : %d\n", sub)
                fmt.Println(sum)
            }
        }
        close(channel1)
        close(channel2)
    }

    "Classiques cluster à base de systèmes (tels que les supercalculateurs) emploient l'exécution parallèle entre les processeurs à l'aide de MPI. MPI est une interface de communication entre les processus qui s'exécutent dans le système d'exploitation instances sur des processeurs différents; il ne supporte pas d'autres opérations, telles que la planification. (Au risque de compliquer encore plus les choses, parce que les processus MPI sont exécutées par les systèmes d'exploitation, un seul processeur peut exécuter plusieurs processus MPI et/ou un seul processus MPI pouvez également exécuter plusieurs threads!)"

    InformationsquelleAutor Wolfie