Bir goroutine kanalından engellemeden okuma

Kolayca doğrulayabilirsiniz

func helper(c chan<- error) {
    time.Sleep(5 * time.Second)
    c <- errors.New("") // send errors/nil on c
}

func worker() error {
    fmt.Println("do one")

    c := make(chan error, 1)
    go helper(c)

    err := <-c
    fmt.Println("do two")

    return err
}

func main() {
    worker()
}

S: İfade err mi: = Kanal tamponlu olduğu için sanmıyorum.

Bir: err := <- c işçiyi engeller.

S: Engelliyorsa, engellememesini nasıl sağlayabilirim? Benim gereksinimim, işçinin ve arayanın, değerin kanalda görünmesini beklemeden işin geri kalanıyla devam etmesini sağlamaktır.

A: engelleme istemiyorsanız, sadece kaldırın err := <-c. Sonunda bir hataya ihtiyacınız varsa, sadece hareket edin err := <-c sonuna kadar.

Engellemeden kanalı okuyamazsınız, engellemeden geçerseniz, kodunuz bir döngü içinde olmadıkça artık bu kodu yürütemezsiniz.

Loop:
    for {
        select {
        case <-c:
            break Loop
        default:
            //default will go through without blocking
        }
        // do something
    }

Ve hiç errgroup veya waitgroup gördünüz mü?

Atomik kullanır, bağlamı iptal eder ve senkronize eder.Bunu uygulamak için bir kez.

https://github.com/golang/sync/blob/master/errgroup/errgroup.go

https://github.com/golang/go/blob/master/src/sync/waitgroup.go

Ya da sadece kullanabilirsiniz, size func gidin ve sonra istediğiniz herhangi bir yerde hata için bekleyin.

Kodunuzda, işin geri kalanı, yardımcının bir hatayla karşılaşıp karşılaşmadığından bağımsızdır. İşin geri kalanı tamamlandıktan sonra kanaldan kolayca alabilirsiniz.

func worker() error {
    //do some work
    c := make(chan error, 1)
    go helper(c)
    //do rest of the work
    return <-c
}

Bence bu koda ihtiyacın var..

bu kodu çalıştır

package main

import (
    "log"
    "sync"
)

func helper(c chan<- error) {

    for {
        var err error = nil
        // do job

        if err != nil {
            c <- err // send errors/nil on c
            break
        }
    }

}

func worker(c chan error) error {
    log.Println("first log")

    go func() {
        helper(c)
    }()

    count := 1
    Loop:
        for {
            select {
            case err := <- c :
                return err
            default:
                log.Println(count, " log")
                count++
                isFinished := false
                // do your job
                if isFinished {
                    break Loop // remove this when you test

                }
            }
        }
    return nil
}

func main() {
    wg := sync.WaitGroup{}
    wg.Add(1)
    go func() {
        c := make(chan error, 1)
        worker(c)
        wg.Done()
    }()
    wg.Wait()
}