select多路选择的模拟实现

有时候有这样一种应用场景：需要等待多个事件到达，然后返回尽可能多的事件；如果没有事件到达就阻塞等待。例如服务器等待客户端建立连接，或者等待客户端数据等就有这种应用需求。

在go语言里，可以利用select原语和它的非阻塞(default)分支组合实现这个功能：

// 从ch获取尽可能多的数据放到events里，并返回实际数量；如果没有数据就阻塞等待
func wait(ch chan int, events []int) int {
    count := 0
    for count < len(events) {
        select {
        case x := <-ch:
            events[count] = x
            count++
        default:
            if count > 0 {
                return count
            }
            events[count] = <-ch
            count++
        }
    }
    return count
}
如果再加上退出检查:
import "errors"

func wait(ch chan int, exit chan bool, events []int) (int, error) {
    count := 0
    for count < len(events) {
        select {
        case <-exit:
            return 0, errors.New("exit")
        case x := <-ch:
            events[count] = x
            count++
        default:
            if count > 0 {
                return count, nil
            }
            select {
            case <-exit:
                return 0, errors.New("exit")
            case x := <-ch:
                events[count] = x
                count++
            }
        }
    }
    return count, nil
}
可以看到，这里的实现有很多重复代码，非常的冗长难读。我们可以利用channel以下特性改写一下：
1.读取或者写入空channel时永久阻塞
2.读取一个已经关闭的channel立即返回空值

import "errors"

var (

CLOSED = make(chan int)
)
func init() {

close(CLOSED)
}
func pass(flag bool) chan int {

if flag {


return CLOSED

}
return nil
}

func wait(ch chan int, exit chan bool, events []int) (int, error) {

count := 0
LOOP:


for count < len(events) {


select {

case <-exit:



return 0, errors.New("exit")


case x := <-ch:



events[count] = x



count++


case <-pass(count > 0):



break LOOP


}

}
return count, nil
}

现在的实现就比较清晰简洁易读。