पढ़ने से एक goroutine चैनल अवरुद्ध बिना

आप कर सकते हैं आसानी से सत्यापित करें

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()
}

क्यू: बयान है गलती := <- सी अवरुद्ध कार्यकर्ता? मैं ऐसा नहीं लगता है के बाद से, चैनल बफर है.

एक: err := <- c ब्लॉक करेगा कार्यकर्ता ।

प्रश्न: यदि यह अवरुद्ध है, मैं कैसे बनाने के लिए यह गैर-अवरुद्ध? मेरी आवश्यकता है करने के लिए कार्यकर्ता और उसके फोन करने वाले के साथ जारी रखने के काम के आराम के बिना, के लिए इंतज़ार कर रही मूल्य पर प्रदर्शित करने के लिए चैनल.

एक: यदि आप नहीं चाहते अवरुद्ध है, बस निकालें err := <-c. अगर आप की जरूरत है गलती अंत में, बस कदम err := <-c अंत करने के लिए.

आप नहीं पढ़ सकते हैं, चैनल रोकने के बिना, आप के माध्यम से जाने के बिना अवरुद्ध कर सकते हैं, कर सकते हैं कोई और अधिक exec इस कोड है, जब तक कि अपने कोड है, एक पाश में.

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

और क्या तुमने कभी देखा errgroup या waitgroup？

यह उपयोग परमाणु रद्द करने के लिए, संदर्भ और सिंक.एक बार इस लागू करने के लिए.

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

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

या आप कर सकते हैं बस का उपयोग करें इसे जाना है, तुम समारोह और फिर प्रतीक्षा करें, त्रुटि के लिए किसी भी जगह में आप चाहते हैं.

अपने कोड में, काम के बाकी है कि क्या से स्वतंत्र सहायक में कोई त्रुटि आई । आप कर सकते हैं बस से प्राप्त चैनल के आराम के बाद काम पूरा हो गया है ।

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

मुझे लगता है कि आप की जरूरत है इस कोड..

इस कोड को चलाने

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()
}