有时 goroutine 不会从通道获取事件数据

Question

My issue is sometimes goroutine NOT get event data from reg.eventCh

NO exit log print, this goroutine is NOT exit, is running.

reg.eventCh channel is NOT closed, log can print length increment.

Logs shows:

reg.eventCh <- event, count: 1
event is coming

reg.eventCh <- event, count: 0  (why count is 0? log print after data in channel)
event is coming

reg.eventCh <- event, count: 1

reg.eventCh <- event, count: 2
.
.
.
reg.eventCh <- event, count: 999

reg.eventCh <- event, count: 1000

log shows DO NOT get event data from reg.eventCh, belows is my codes：

reg := &Reg{}
reg.exitCh = make(chan *demo.Exit)
reg.eventCh = make(chan *demo.Event, 1000)

go reader(reg)

// other goroutine will writer event to reg.eventCh like:

reg.eventCh <- event
log.Println("reg.eventCh <- event, count:",len(reg.eventCh))


func reader(reg *Reg) {
    for {
        select {
            case event := <-reg.eventCh:
                log.Println("event is coming")
                handler(event)
            case exit := reg.exitCh:
                log.Println("exit")
                return
        }
    }
}

Is my codes something wrong?

any help will be appreciated,

Thanks,

Jimmy

demo code：

package main

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

type Event struct {
    testStr string
}

type Exit struct {
    testStr string
}

type Reg struct {
    des     string
    eventCh chan *Event
    exitCh  chan *Exit
}

// this demo code like my issue
// this issue is sometimes case event := <-reg.eventCh NOT work in go reader()
func main() {
    reg := &Reg{}
    reg.des = "sometime not read from reg.eventCh"
    reg.eventCh = make(chan *Event, 1000)
    reg.exitCh = make(chan *Exit)

    // read data from channel
    go reader(reg)

    // simulate data: write in channel
    for i := 0; i < 10; i++ {
        go writer(reg)
    }

    select {}
}

func writer(reg *Reg) {
    for {
        time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
        event := new(Event)
        event.testStr = "1"
        reg.eventCh <- event
        log.Println("reg.eventCh <- event, channel count:", len(reg.eventCh))
    }
}

func reader(reg *Reg) {
    for {
        select {
        case event := <-reg.eventCh:
            log.Println("event is coming, channel count:", len(reg.eventCh))
            handler(event)
        case exit := <-reg.exitCh:
            log.Println("goroutine exit: ", exit)
            return
        }
    }
}

func handler(e *Event) {
    // logic codes
}

need time to repro this issue。

Answer 1

Your code has some errors, It dont send data to exitCh. it dont has stop condition and deadlock block. I will share my answer by answering 3 questions I raised.

Question#1 : why count is 0? log print after data in channel why count is 0? log print after data in channel

len(channel) is only useful to know how much data is currently available. If the recipient has already received the data, it will always be 0.

Question#2 : why use select like exit control?

you could use <-context.Done() or others code more idiomatic.

Question#3 : why there is no data for exitCh?

apparently you created an exitch to get out of the loop, but it's not working

Code sugestion:

package main

import (
    "context"
    "fmt"
    "log"
)

var (
    ctx, cancel = context.WithCancel(context.Background())
)

type Event struct {
    testStr string
}

type Exit struct {
    testStr string
}

type Reg struct {
    des     string
    eventCh chan *Event
    exitCh  chan *Exit
}

// this demo code like my issue
// this issue is sometimes case event := <-reg.eventCh NOT work in go reader()
func main() {
    //
    reg := &Reg{}
    reg.des = "sometime not read from reg.eventCh"
    reg.eventCh = make(chan *Event, 1000)
    reg.exitCh = make(chan *Exit)

    // read data from channel
    go reader(reg)

    // simulate data: write in channel
    for i := 0; i < 10; i++ {
        go writer(reg, fmt.Sprintf("gorouinte-%d", i))
    }
    // notify exit
    <-ctx.Done()
}

func writer(reg *Reg, tname string) {
    for /* infinity loop */ {
        // time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
        event := new(Event)
        event.testStr = "1"
        reg.eventCh <- event
        log.Println("reg.eventCh <- event, channel count:", len(reg.eventCh))
        // simulates stop condition
        if len(reg.eventCh) == 1000 {
            reg.exitCh <- &Exit{"exit now!"}
            log.Printf("stop write loop in routine %s\n", tname)
            return
        }
    }
}

func reader(reg *Reg) {
    for {
        select {
        case event := <-reg.eventCh:
            log.Println("event is comming, channel count:", len(reg.eventCh))
            handler(event)
        case exit := <-reg.exitCh:
            log.Println("goroutine exit: ", exit)
            cancel() // used to exit this program
            return
        }
    }
}

func handler(e *Event) {
    // logic codes
}

Playground demo