에서 읽 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()
}

Q:문 err:=<-c 차단 노동자가 있습니까? 그렇게 생각하지 않기 때문에,채널은 버퍼링됩니다.

A: err := <- c 을 차단 노동자입니다.

Q:차단하는 경우,어떻게 그것을 차단하지 않는? 나의 요구 사항은 근로자와 그 발신자가 계속 작업의 나머지를 기다리지 않고,값에 나타나는 채널이 있습니다.

A: 원하지 않는 경우 차단,제거 err := <-c. 필요할 경우 err 끝에서,이동 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 기다리는 다음에 대한 오류는 당신이 원하는 어떤 장소에서.

에서 당신의 코드의 나머지 작품은 독립적인지 여부를 도우미에서 오류가 발생했습니다. 당신은 단순히 수신 채널에서 후에의 나머지 작업이 완료됩니다.

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