golang等待触发事件

type Wait interface {
   // Register waits returns a chan that waits on the given ID.
   // The chan will be triggered when Trigger is called with
   // the same ID.
   Register(id uint64) <-chan interface{}
   // Trigger triggers the waiting chans with the given ID.
   Trigger(id uint64, x interface{})
   IsRegistered(id uint64) bool
}

type list struct {
   l sync.RWMutex
   m map[uint64]chan interface{}
}

func Newlist() Wait {
   return &list{m : make(map[uint64]chan interface{})}
}


//注册
func (w *list) Register(id uint64) <-chan interface{} {
   w.l.Lock()
   defer w.l.Unlock()
   ch := w.m[id]
   if ch != nil {
      log.Fatal("dup id error")
      return nil
   }
   ch = make(chan interface{},1)
   w.m[id] = ch
   return ch
}

//触发
func (w *list) Trigger(id uint64, x interface{}) {
   w.l.Lock()
   ch := w.m[id]
   delete(w.m,id)
   w.l.Unlock()
   if ch != nil {
      ch <- x
      close(ch)
   }
}

//判断该id是否被注册
func (w *list) IsRegistered(id uint64) bool {
   w.l.RLock()
   defer w.l.Unlock()
   _,ok := w.m[id]
   return ok
}

//示例

var timeOutDuration = time.Minute*10

func main() {
	list := Newlist()
	rid := uint64(time.Now().UnixNano())
	go func() {
		ch := list.Register(rid)
		fmt.Println("start register:",rid)
		if ch == nil {
			return
		}
		select {
		case x := <- ch:
			fmt.Printf("trigger over id:%d,x:%v\n",rid,x)
		case <-time.After(timeOutDuration):
			log.Println("timeout error:",rid)
		}
	}()
	time.Sleep(time.Second)

	rid2 := uint64(time.Now().UnixNano())
	go func() {
		ch := list.Register(rid2)
		fmt.Println("start register:",rid2)
		if ch == nil {
			return
		}
		select {
		case x := <- ch:
			fmt.Printf("trigger over id:%d,x:%v\n",rid2,x)
		case <-time.After(timeOutDuration):
			log.Println("timeout error:",rid2)
		}
	}()

	go func() {
		time.Sleep(time.Second*5)
		list.Trigger(rid,"Hello")
		time.Sleep(time.Second*3)
		list.Trigger(rid2,"World")
	}()

	select {

	}
}