อ่านจาก 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 จอดปิดทางงาน? ฉันไม่คิดอย่างนั้นตั้งแต่ที่ช่อง buffered.

เป็น: err := <- c จะปิดงาน

Q ถ้ามันเป็นการปิดกั้นจะทำยังไงให้มันไม่ใช่การปิดกั้น? ของฉันสำคัญที่สุคือต้องมีคนงานและมันโทรบอกต่อไปด้วยเหลือของทำงานโดยไม่รออยู่สำหรับค่าที่จะปรากฎบนช่อง

เป็น: หากคุณไม่ต้องการการปิดกั้นแค่ลบ err := <-c. ถ้าคุณต้องการ err ที่สุดเพิ่งย้าย err := <-c ไปจนถึงจุดจบ

คุณไม่สามารถอ่านช่องโดยไม่มีการปิดกั้นถ้าคุณผ่านไปโดยไม่มีการปิดกั้นสามารถได้ไม่มากไปกประมวลผลดรหัสนี้,เว้นแต่ว่ารหัสของคุณอยู่ในเรื่อยๆ

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

และคุณเคยเห็น errgroup หรือ waitgroup？

มันใช้อะตอมยกเลิกกับคอนเท็กซ์ข sync.ครั้งเดียวที่จะรับคำสั่งเข้าใจเรื่องนี้

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

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

หรือคุณสามารถใช้มันไปคุณ func แล้วจากนั้นก็รอให้เกิดข้อผิดพลาดในสถานที่ที่คุณต้องการ

ในของคุณรหัสที่เหลือของงานอิสระของหรือไม่ช่วยพบมาเป็นข้อผิดพลาด คุณสามารถเพียงรับมาจากช่องหลังจากที่เหลือของที่ทำงานเสร็จสมบูรณ์@info:status

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