Путаница о потоке управления каналом

Question

Я пытаюсь написать прослушиватель событий и попытаться контролировать поток состояния внутри слушателя. Я знал, что пропустил какой-то принцип использования канала, и код может выглядеть глупо. Тем не менее, я буду признателен, если кто-то может помочь мне понять, что моя ошибка и как ее улучшить.

Этот код не может работать:

package main 

import (
    "fmt" 
    "time" 
) 

type A struct { 
    count int 
    ch chan bool 
    exit chan bool 
} 

func (this *A) Run() { 
    for { 
     select { 
     case <-this.ch: 
      this.handler() 
     case <-this.exit: 
      return 
     default: 
      time.Sleep(20 * time.Millisecond) 
     } 
    } 
} 

func (this *A) handler() { 
    println("hit me") 
    if this.count > 2 { 
     this.exit <- true 
    } 
    fmt.Println(this.count) 
    this.count += 1 
} 

func (this *A) Hit() { 
    this.ch <- true 
} 

func main() { 
    a := &A{} 
    a.ch = make(chan bool) 
    a.exit = make(chan bool) 

    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    a.Run() 

    fmt.Println("s") 
} 

это поднять ошибку:

hit me 
0 
hit me 
1 
hit me 
2 
hit me 
fatal error: all goroutines are asleep - deadlock! 

goroutine 1 [chan send]: 
main.(*A).handler(0x2101bf000) 
/Users/yeer/go/src/github.com/athom/practice/channel-controll.go:31 +0x60 
main.(*A).Run(0x2101bf000) 
/Users/yeer/go/src/github.com/athom/practice/channel-controll.go:19 +0x66 
main.main() 
/Users/yeer/go/src/github.com/athom/practice/channel-controll.go:50 +0xed 
exit status 2 

Однако, этот код работает:

package main 

import (
    "fmt" 
    "time" 
) 

type A struct { 
    count int 
    ch chan bool 
    exit chan bool 
} 

func (this *A) Run() { 
    for { 
     select { 
     case <-this.ch: 
      this.handler() 
     case <-this.exit: 
      return 
     default: 
      time.Sleep(20 * time.Millisecond) 
     } 
    } 
} 

func (this *A) handler() { 
    println("hit me") 
} 

func (this *A) Hit() { 
    this.ch <- true 
    if this.count > 2 { 
     this.exit <- true 
    } 
    fmt.Println(this.count) 
    this.count += 1 
} 

func main() { 
    a := &A{} 
    a.ch = make(chan bool) 
    a.exit = make(chan bool) 

    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    a.Run() 

    fmt.Println("s") 
} 

Почему не может вызвать другой канал в один и тот же канальный обработчик уровня?

Answer 1

Ваш код заблокирован, потому что, когда вы отправляете по выходному каналу this.exit <- true, который является тем же самым каналом, который вы получаете с этого канала, и нет никакого способа, который когда-либо будет завершен.

Возможно, наиболее разумной задачей является замена выходного канала логическим флагом. Если вы это сделаете, тогда все будет хорошо.

Play

type A struct { 
    count int 
    ch chan bool 
    exit bool 
} 

func (this *A) Run() { 
    for !this.exit { 
     select { 
     case <-this.ch: 
      this.handler() 
     default: 
      time.Sleep(20 * time.Millisecond) 
     } 
    } 
} 

func (this *A) handler() { 
    println("hit me") 
    if this.count > 2 { 
     this.exit = true 
    } 
    fmt.Println(this.count) 
    this.count += 1 
} 

func (this *A) Hit() { 
    this.ch <- true 
} 

func main() { 
    a := &A{} 
    a.ch = make(chan bool) 

    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    a.Run() 

    fmt.Println("Done") 
} 

Другой альтернативой будет запускать каждый обработчик в своей рутине идут с go this.handler()

Play

func (this *A) Run() { 
    for { 
     select { 
     case <-this.ch: 
      go this.handler() // add go here 
     case <-this.exit: 
      return 
     default: 
      time.Sleep(20 * time.Millisecond) 
     } 
    } 
} 

И, наконец, вы могли бы буфер выходного канала

Play

func main() { 
    a := &A{} 
    a.ch = make(chan bool) 
    a.exit = make(chan bool, 5) // add buffer here 

    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    go a.Hit() 
    a.Run() 

    fmt.Println("Done") 
} 

Answer 2

Вы должны использовать Time.after() для ожидания в цикле:

select { 
    case <-this.ch: 
     go this.handler() // add go here 
    case <-this.exit: 
     return 
    case <-time.After(20 * time.Millisecond)