我是新手，我正在尝试创建一个简单的聊天服务器，客户端可以向所有连接的客户端广播消息。
在我的服务器中，我有一个goroutine（无限循环）接受连接，所有连接都由一个通道接收。
go func() {
for {
conn, _ := listener.Accept()
ch <- conn
}
}()
然后，我为每个连接的客户端启动一个处理程序（goroutine）。在处理程序内部，我尝试通过迭代通道来广播所有连接。
for c := range ch {
conn.Write(msg)
}
但是，我无法播放，因为（我想通过阅读文档）在迭代之前需要关闭频道。我不确定何时应该关闭频道，因为我想继续接受新的连接，关闭频道不会让我这样做。如果有人可以帮助我，或提供更好的方式向所有连接的客户广播消息，我们将不胜感激。
答案 0 :(得分：33)
您正在做的是扇出模式，也就是说，多个端点正在侦听单个输入源。这种模式的结果是，只要输入源中有消息，这些侦听器中只有一个能够获取消息。唯一的例外是close频道。这个close将被所有听众识别，因此是“广播”。
但你要做的是广播从连接中读取的消息，所以我们可以这样做：
让每个工作人员收听专用广播频道，并将消息从主频道发送到每个专用广播频道。
type worker struct {
source chan interface{}
quit chan struct{}
}
func (w *worker) Start() {
w.source = make(chan interface{}, 10) // some buffer size to avoid blocking
go func() {
for {
select {
case msg := <-w.source
// do something with msg
case <-quit: // will explain this in the last section
return
}
}
}()
}
然后我们可以有一堆工人：
workers := []*worker{&worker{}, &worker{}}
for _, worker := range workers { worker.Start() }
然后开始我们的听众：
go func() {
for {
conn, _ := listener.Accept()
ch <- conn
}
}()
和调度员：
go func() {
for {
msg := <- ch
for _, worker := workers {
worker.source <- msg
}
}
}()
在这种情况下，上面给出的解决方案仍然有效。唯一的区别是，无论何时需要新工作人员，您都需要创建一个新工作人员，启动它，然后将其推入workers切片。但是这种方法需要一个线程安全的切片，需要锁定它。其中一个实现可能如下所示：
type threadSafeSlice struct {
sync.Mutex
workers []*worker
}
func (slice *threadSafeSlice) Push(w *worker) {
slice.Lock()
defer slice.Unlock()
workers = append(workers, w)
}
func (slice *threadSafeSlice) Iter(routine func(*worker)) {
slice.Lock()
defer slice.Unlock()
for _, worker := range workers {
routine(worker)
}
}
每当你想要开始一个工人时：
w := &worker{}
w.Start()
threadSafeSlice.Push(w)
您的调度员将更改为：
go func() {
for {
msg := <- ch
threadSafeSlice.Iter(func(w *worker) { w.source <- msg })
}
}()
其中一个好习惯是：永远不要留下悬垂的goroutine。所以当你听完之后，你需要关闭你开枪的所有goroutine。这将通过quit中的worker频道完成：
首先，我们需要创建一个全局quit信令通道：
globalQuit := make(chan struct{})
无论何时我们创建一个工作人员，我们都会将globalQuit频道指定给它作为其退出信号：
worker.quit = globalQuit
然后，当我们要关闭所有工人时，我们只需：
close(globalQuit)
由于close将被所有收听goroutine识别（这是您理解的点），因此将返回所有goroutines。记得关闭你的调度程序例程，但我会留给你：）
答案 1 :(得分：10)
更优雅的解决方案是＆＃34;经纪人＆＃34;，客户可以订阅和取消订阅消息。
为了优雅地处理订阅和取消订阅，我们可以为此使用通道，因此接收和分发消息的代理的主循环可以使用单个select语句合并所有这些，并且同步来自解决方案的本质。
另一个技巧是将订阅者存储在地图中，从我们用于向其分发消息的频道进行映射。因此，使用频道作为地图中的关键字，然后添加和删除客户端是＃34; dead＆＃34;简单。这是可能的，因为通道值是comparable，并且它们的比较非常有效，因为通道值是通道描述符的简单指针。
不用多说，这是一个简单的经纪人实施：
type Broker struct {
stopCh chan struct{}
publishCh chan interface{}
subCh chan chan interface{}
unsubCh chan chan interface{}
}
func NewBroker() *Broker {
return &Broker{
stopCh: make(chan struct{}),
publishCh: make(chan interface{}, 1),
subCh: make(chan chan interface{}, 1),
unsubCh: make(chan chan interface{}, 1),
}
}
func (b *Broker) Start() {
subs := map[chan interface{}]struct{}{}
for {
select {
case <-b.stopCh:
return
case msgCh := <-b.subCh:
subs[msgCh] = struct{}{}
case msgCh := <-b.unsubCh:
delete(subs, msgCh)
case msg := <-b.publishCh:
for msgCh := range subs {
// msgCh is buffered, use non-blocking send to protect the broker:
select {
case msgCh <- msg:
default:
}
}
}
}
}
func (b *Broker) Stop() {
close(b.stopCh)
}
func (b *Broker) Subscribe() chan interface{} {
msgCh := make(chan interface{}, 5)
b.subCh <- msgCh
return msgCh
}
func (b *Broker) Unsubscribe(msgCh chan interface{}) {
b.unsubCh <- msgCh
}
func (b *Broker) Publish(msg interface{}) {
b.publishCh <- msg
}
使用它的示例：
func main() {
// Create and start a broker:
b := NewBroker()
go b.Start()
// Create and subscribe 3 clients:
clientFunc := func(id int) {
msgCh := b.Subscribe()
for {
fmt.Printf("Client %d got message: %v\n", id, <-msgCh)
}
}
for i := 0; i < 3; i++ {
go clientFunc(i)
}
// Start publishing messages:
go func() {
for msgId := 0; ; msgId++ {
b.Publish(fmt.Sprintf("msg#%d", msgId))
time.Sleep(300 * time.Millisecond)
}
}()
time.Sleep(time.Second)
}
上面的输出将是（在Go Playground上尝试）：
Client 2 got message: msg#0
Client 0 got message: msg#0
Client 1 got message: msg#0
Client 2 got message: msg#1
Client 0 got message: msg#1
Client 1 got message: msg#1
Client 1 got message: msg#2
Client 2 got message: msg#2
Client 0 got message: msg#2
Client 2 got message: msg#3
Client 0 got message: msg#3
Client 1 got message: msg#3
您可以考虑以下改进。根据您使用经纪人的方式/用途，这些可能有用也可能没用。
Broker.Unsubscribe()可以关闭消息通道，表示不再发送消息：
func (b *Broker) Unsubscribe(msgCh chan interface{}) {
b.unsubCh <- msgCh
close(msgCh)
}
这将允许客户通过消息通道range，如下所示：
msgCh := b.Subscribe()
for msg := range msgCh {
fmt.Printf("Client %d got message: %v\n", id, msg)
}
然后，如果有人取消订阅此msgCh，请执行以下操作：
b.Unsubscribe(msgCh)
上述范围循环将在处理调用Unsubscribe()之前发送的所有邮件后终止。
如果您希望您的客户依赖关闭的消息渠道，并且经纪人的生命周期比您应用程序的生命周期更短，那么您也可以在经纪人停止时关闭所有订阅的客户端，在Start()方法中，如下所示：
case <-b.stopCh:
for msgCh := range subs {
close(msgCh)
}
return
答案 2 :(得分：1)
这是一个较晚的答案，但我认为它可能会安抚一些好奇的读者。
在并发方面，Go通道受到广泛欢迎。
Go 社区严格遵循以下说法：
请勿通过共享内存进行通信；而是通过通信共享内存。
对此我完全持中立态度，我认为在广播时应考虑其他选项，而不是定义明确的channels。
这是我的看法：同步程序包中的cond为widely overlooked。值得注意的是，青铜人建议的实施Braodcaster。
我很高兴icza建议使用频道并在频道上广播消息。我遵循相同的方法，并使用sync的条件变量：
// Broadcaster is the struct which encompasses broadcasting
type Broadcaster struct {
cond *sync.Cond
subscribers map[interface{}]func(interface{})
message interface{}
running bool
}
这是我们整个广播概念所依赖的主要结构。
下面，我为此结构定义一些行为。简而言之，应该可以添加，删除订户，并且可以撤消整个过程。
// SetupBroadcaster gives the broadcaster object to be used further in messaging
func SetupBroadcaster() *Broadcaster {
return &Broadcaster{
cond: sync.NewCond(&sync.RWMutex{}),
subscribers: map[interface{}]func(interface{}){},
}
}
// Subscribe let others enroll in broadcast event!
func (b *Broadcaster) Subscribe(id interface{}, f func(input interface{})) {
b.subscribers[id] = f
}
// Unsubscribe stop receiving broadcasting
func (b *Broadcaster) Unsubscribe(id interface{}) {
b.cond.L.Lock()
delete(b.subscribers, id)
b.cond.L.Unlock()
}
// Publish publishes the message
func (b *Broadcaster) Publish(message interface{}) {
go func() {
b.cond.L.Lock()
b.message = message
b.cond.Broadcast()
b.cond.L.Unlock()
}()
}
// Start the main broadcasting event
func (b *Broadcaster) Start() {
b.running = true
for b.running {
b.cond.L.Lock()
b.cond.Wait()
go func() {
for _, f := range b.subscribers {
f(b.message) // publishes the message
}
}()
b.cond.L.Unlock()
}
}
// Stop broadcasting event
func (b *Broadcaster) Stop() {
b.running = false
}
接下来，我可以很容易地使用它：
messageToaster := func(message interface{}) {
fmt.Printf("[New Message]: %v\n", message)
}
unwillingReceiver := func(message interface{}) {
fmt.Println("Do not disturb!")
}
broadcaster := SetupBroadcaster()
broadcaster.Subscribe(1, messageToaster)
broadcaster.Subscribe(2, messageToaster)
broadcaster.Subscribe(3, unwillingReceiver)
go broadcaster.Start()
broadcaster.Publish("Hello!")
time.Sleep(time.Second)
broadcaster.Unsubscribe(3)
broadcaster.Publish("Goodbye!")
它应该以任何顺序打印以下内容：
[New Message]: Hello!
Do not disturb!
[New Message]: Hello!
[New Message]: Goodbye!
[New Message]: Goodbye!
在go playground上查看此
答案 3 :(得分：1)
另一个简单的例子： https://play.golang.org
<script src = "http://code.jquery.com/jquery-latest.js"></script>
<script src = "https://www.gstatic.com/charts/loader.js"></script>
<script src = "https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
输出：
type Broadcaster struct {
mu sync.Mutex
clients map[int64]chan struct{}
}
func NewBroadcaster() *Broadcaster {
return &Broadcaster{
clients: make(map[int64]chan struct{}),
}
}
func (b *Broadcaster) Subscribe(id int64) (<-chan struct{}, error) {
defer b.mu.Unlock()
b.mu.Lock()
s := make(chan struct{}, 1)
if _, ok := b.clients[id]; ok {
return nil, fmt.Errorf("signal %d already exist", id)
}
b.clients[id] = s
return b.clients[id], nil
}
func (b *Broadcaster) Unsubscribe(id int64) {
defer b.mu.Unlock()
b.mu.Lock()
if _, ok := b.clients[id]; ok {
close(b.clients[id])
}
delete(b.clients, id)
}
func (b *Broadcaster) broadcast() {
defer b.mu.Unlock()
b.mu.Lock()
for k := range b.clients {
if len(b.clients[k]) == 0 {
b.clients[k] <- struct{}{}
}
}
}
type testClient struct {
name string
signal <-chan struct{}
signalID int64
brd *Broadcaster
}
func (c *testClient) doWork() {
i := 0
for range c.signal {
fmt.Println(c.name, "do work", i)
if i > 2 {
c.brd.Unsubscribe(c.signalID)
fmt.Println(c.name, "unsubscribed")
}
i++
}
fmt.Println(c.name, "done")
}
func main() {
var err error
brd := NewBroadcaster()
clients := make([]*testClient, 0)
for i := 0; i < 3; i++ {
c := &testClient{
name: fmt.Sprint("client:", i),
signalID: time.Now().UnixNano()+int64(i), // +int64(i) for play.golang.org
brd: brd,
}
c.signal, err = brd.Subscribe(c.signalID)
if err != nil {
log.Fatal(err)
}
clients = append(clients, c)
}
for i := 0; i < len(clients); i++ {
go clients[i].doWork()
}
for i := 0; i < 6; i++ {
brd.broadcast()
time.Sleep(time.Second)
}
}
答案 4 :(得分：0)
由于Go通道遵循通信顺序进程（CSP）模式，因此通道是点对点通信实体。每次交流都有一位作家和一位读者参与。
但是，每个频道 end 可以在多个goroutine中共享。这样做是安全的 - 没有危险的竞争条件。
因此可以有多个作者共享写作结束。和/或可以有多个读者共享阅读结束。我在different answer中写了更多内容，其中包括示例。
如果你真的需要广播，你不能直接这样做，但是实现一个将值复制到一组输出通道中的每一个的中间goroutine并不难。
答案 5 :(得分：0)
我创建了一个简单的库来支持频道广播。这可用于广播许多现代服务API调用的异步结果。 https://github.com/guiguan/caster#broadcast-a-go-channel