```go
// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.
// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
// See page 254.
// Chat is a server that lets clients chat with each other.
package main
import (
"bufio"
"fmt"
"log"
"net"
)
type client chan<- string // an outgoing message channel
var (
entering = make(chan client)
leaving = make(chan client)
messages = make(chan string) // all incoming client messages
)
//负责广播的goroutine,抱有疑问,这个函数用一个for死循环嵌套了一个select,通过select去选择性地匹配某一个case,但这些case中好像没有与clientWriter的goroutine通过channel之间进行交流呢,我不太理解,从handleConn中接受的messages是如何通过broadcaster与clientWriter广播写入连接conn中去的呢?
//entering与leaving在整个过程中又起到什么作用呢?如果去掉这两个通道又会如何?
func broadcaster() {
clients := make(map[client]bool) // all connected clients
for {
select {
case msg := <-messages:
// Broadcast incoming message to all
// clients' outgoing message channels.
for cli := range clients {
cli <- msg
}
case cli := <-entering:
clients[cli] = true
case cli := <-leaving:
delete(clients, cli)
close(cli)
}
}
}
//处理连接的goroutine,每一个客户端与服务器建立的连接都会新开一个goroutine,相互独立。在这个函数中,又开了一个goroutine,并发执行clientWriter,将handleConn的局部变量写入conn中。
func handleConn(conn net.Conn) {
ch := make(chan string) // outgoing client messages
go clientWriter(conn, ch)
who := conn.RemoteAddr().String()
//1.用A客户端建立连接,“You are ‘主机ip’”传入局部通道ch,此时执行clientWriter的goroutine将结束阻塞,将传入通道的“You are ‘主机ip’”写入连接conn,“You are ‘主机ip’”会返回至A客户端终端中显示。
ch <- "You are " + who
//2.“‘主机ip’ has arrived”传入全局通道messages中,“‘主机ip’ has arrived”不会返回至A客户端终端中,如果此时有B客户端与服务器保持连接,那么“‘主机ip’ has arrived”会返回至B客户端,这是为什么?
messages <- who + " has arrived"
//3.ch中的消息传给entering这个通道去,我不是很理解这一句话,ch是一个无缓冲通道,即容量为1,刚才注释第一点说了,clientWriter会将通道ch中的消息接收,这样ch中不就没有值了么,这样enter <- ch不就阻塞了么?
entering <- ch
//4.通过扫描conn中的客户端A写入conn中的信息,将其取出,传入messages通道中,即“‘主机ip’:‘A客户端写入conn的信息’”;最后这个字符串“‘主机ip’:‘A客户端写入conn的信息’”会在A,B客户端的终端显示,这是为什么呢?执行broadcaster()的goroutine并没有将messages的内容发送至某处并将其写入conn的操作啊?
input := bufio.NewScanner(conn)
for input.Scan() {
messages <- who + ": " + input.Text()
}
// NOTE: ignoring potential errors from input.Err()
//5.若客户端A写入连接“control+z”,那么ch会发送至通道leaving,但ch里面不是没有值么,不是会阻塞么?"主机A has left"会发送至通道messages,最后B客户端终端会显示"主机A has left"。
leaving <- ch
messages <- who + " has left"
conn.Close()
}
//负责写入conn的goroutine,将单向in通道ch的消息写入conn中(每条连接是相互独立的goroutine)
func clientWriter(conn net.Conn, ch <-chan string) {
for msg := range ch {
fmt.Fprintln(conn, msg) // NOTE: ignoring network errors
}
}
//三个goroutine(broadcaster,handleConn和clientWriter)通过channel进行通信。
func main() {
listener, err := net.Listen("tcp", "localhost:8000")
if err != nil {
log.Fatal(err)
}
go broadcaster()
for {
conn, err := listener.Accept()
if err != nil {
log.Print(err)
continue
}
go handleConn(conn)
}
}
```
**总结一下我的问题:**
1.(Line 54)“‘主机ip’ has arrived”传入全局通道messages中,“‘主机ip’ has arrived”不会返回至A客户端终端中,如果此时有B客户端与服务器保持连接,那么“‘主机ip’ has arrived”会返回至B客户端,这是为什么?
2.(Line56-59)通过扫描conn中的客户端A写入conn中的信息,将其取出,传入messages通道中,即“‘主机ip’:‘A客户端写入conn的信息’”;最后这个字符串“‘主机ip’:‘A客户端写入conn的信息’”会在A,B客户端的终端显示,这是为什么呢?执行broadcaster()的goroutine并没有将messages的内容发送至某处并将其写入conn的操作啊?
3.(Line23-40,function broadcaster)负责广播的goroutine,抱有疑问,这个函数用一个for死循环嵌套了一个select,通过select去选择性地匹配某一个case,但这些case中好像没有与clientWriter的goroutine通过channel之间进行交流呢,我不太理解,从handleConn中接受的messages是如何通过broadcaster与clientWriter广播写入连接conn中去的呢?
4.(Line55)ch中的消息传给entering这个通道去,我不是很理解这一句话,ch是一个无缓冲通道,即容量为1,而clientWriter会将通道ch中的消息接收,这样ch中不就没有值了么,这样enter <- ch不就阻塞了么?
5.(Line61)若客户端A写入连接“control+z”,那么ch会发送至通道leaving,但ch里面不是没有值么,不是会阻塞么?”主机A has left”会发送至通道messages,最后B客户端终端会显示”主机A has left”。
6.entering与leaving这两个全局通道在整个过程中又起到什么作用呢?如果去掉这两个通道又会如何?
谢谢,希望有哪位能回答我的疑惑~感激不尽!!
首先,非常谢谢大家耐心的解答~
我是新手。。接触go不是特别久,甚至刚参加工作不久,写的代码不是特别多。
1.第一个问题我明白了,就是先发消息再注册客户端的问题。
2.发送消息的ClientWriter我是理解的,即从ch这个通道中接收值再发送到conn中去的,只不过,一开始我所疑惑的点是,首先我们在handleConn里定义的一个string类型的局部通道:
#Line44
`ch := make(chan string)`
然后,开goroutine并发执行ClientWriter,即从ch中取出string字符串写入连接中:
#Line45
`go clientWriter(conn, ch)`
#Line66-70
`for msg := range ch { fmt.Fprintln(conn, msg) }`
而每次写入的消息仅为handleConn里定义的局部通道ch里面接收到的string类型字符串:
#Line48
`ch <- "You are " + who`
如果messages是通过ClientWriter写入conn的话,除此之外,我没有看到除了45行显示调用ClientWriter的其他代码
#Line45
`go clientWriter(conn, ch)`
就此45行,传入ClientWriter的也只有ch这个定义在handleConn里的局部通道而已,那么messages接收的一系列string字符串,如
#Line50
`messages <- who + " has arrived"`
#Line61
`messages <- who + " has left"`
是如何传递给ClientWriter写入连接的呢?
在Broadcaster里,对messages的操作:
#Line27-32
`case msg := <-messages:`
` for cli := range clients {`
` cli <- msg`
`}`
一开始,在发布这个问题的时候,按照我的理解,首先将messages通道里面string类型的消息msg取出来,再将有登记注册到clients这个map里面的客户端cli取出来,然后将msg发送到cli这个通道中去,那么需要广播的消息再cli这个通道,这里并没有将cli里面的消息发送至所有客户端连接去的操作啊?也并没有显示调用ClientWriter?如何实现广播消息到每个客户端的呢?
**随后,这个疑问在大家的帮助下,再经过一些思考,逐渐懂了:
确实除了第45行的显式调用ClientWriter以外,这个程序没有别的地方有显式调用ClientWriter了。但是,我们依旧是可以将每个客户端的messages发送到所有的conn里面去的,因为通过第52行`entering <- ch`,将ch这个代表连接的chan string类型的通道放到了专门用于存放客户端连接通道的通道中(chan chan string类型),假设有客户端A,B,C连接服务器,那么在主goroutine中会开三个handleConn的goroutine分别处理A,B, C的连接,就会有三个不同的客户端通道cha,chb,chc先后存放entering里面,然后从entering里面接收登记注册到Broadcaster里面的clients这个管理连接的map里面(map[chan string]bool),Broadcaster是由主goroutine里面开的另外一个的goroutine来执行的,所以会实时select(匹配),一有客户端消息写入连接,先在handleConn的三个goroutine中分别扫描客户端A,B, C的conn中的消息,一有消息扫描到就发送到messages这个通道中(#Line56)。然后Broadcaster这个goroutine会select到这个case(msg := <-messages),将messages中的消息取出来放到变量msg(string类型),再将所有通过entering登记注册到clients的客户端(chan string类型)cli取出来(这里的cli其实就是在每个客户端连接到服务器打开的用于执行handleConn的goroutine里面的ch,客户端A,B和C分别为cha,chb和chc,因为通过`entering <- ch`和` case cli <- entering: clients[cli] = true`这两句代码传递的通道是同一个通道,指向的是底层同一个地址),将msg放到cli里面(将每个客户端的msg通过遍历clients这个map发送到每个cli(即把messages中每个msg发送到每个客户端的ch通道里面,即广播)),在每个handleConn的goroutine里面又有ClientWriter这个goroutine会随时将每个客户端ch里面的消息写入到conn里面。**
3.第三个问题的理解同上
4.5.第四第五个问题看了回复里各位朋友的回答懂了不少
#Line48
`ch <- "You are " + who`
#Line52
`entering <- ch`
#Line66-70
`for msg := range ch { fmt.Fprintln(conn, msg) }`
#Line33
`case cli := <-entering:`
**这四句话并不会导致程序阻塞,第48行,将“You are 主机ip”发送至通道ch中,随后ClientWriter的Goroutine中(第66-70行),会通过for range接收ch里面的消息写入conn,这个消费行为消费的是ch(chan string)里的消息,一发一收不会造成阻塞;第52行:entering <- ch,也不会造成阻塞,entering这个通道(chan chan string)存放的元素是chan string类型的客户端通道,这句代码只是将ch这个chan string通道发送到entering通道里,ch这个通道是代表一个客户端的通道,而ch这个通道里存放的是此客户端的消息。52行和66行的接收并不会造成程序的阻塞。**
6.第六个问题,entering,leaving这两个通道是什么作用,以及怎么管理连接的我也明白了,主要是在handleConn和Broadcaster中登记注册上线和离线的客户端。
我一开始理解有问题,朋友们的回复,加上一些思考,最终理解了整个过程,非常感谢。
特别感谢:jarlyyn ,dong-hao ,tk103331。
#5
更多评论
没看过这本书,这段代码看了几遍,写的真心奇葩。
问题1:
代码中50行开始群发消息,52行才把A客户端加入队列
(52行加入entering队列,34行从entering队列加入clients,32行-32行负责对所有clients里的内容进行广播)
所以这是先发送消息再注册客户端的问题。
问题2:
发送消息在67-69行,不清楚range一个chan的用法的话参考
https://tour.golang.org/concurrency/4
问题3:
同2。你可以理解每一个entering是一个消息队列。通过这个来发送的
问题4.
entering有消费者啊,第33行。
问题5
同问题4,第35行
问题6
起到不同协程之间通信的作用,分配任务和数据。
去掉你就没法调控各个线程了。
#1
简单回答一下:
1.
```
messages <- who + " has arrived"
```
这句是向 messages 传递了一个字符串,而 messages 拿到后会向所有的已经进入 clients 这个 map 的客户端传递,此时,你所谓的 A客户端 还并未被进入 clients,这个进入动作要到 entering <- ch 才会被执行
2.
同上,此时执行的
```
messages <- who + ": " + input.Text()
```
已经是当前的 A客户端 进入 clients 之后了,自然会收到消息了。
3.
需要注意到
```
var (
entering = make(chan client)
leaving = make(chan client)
messages = make(chan string) // all incoming client messages
)
```
这是三个全局变量,保证了 broadcaster 与 handleConn 的交流,而 44 行的 ch := make(chan string) 则保证了 handleConn 与 clientWriter 的交流
4.
ch是一个无缓冲通道,即容量为1 这句话错了,无缓冲渠道,容量为 0.
entering 是个以 chan<- string 为传递值得渠道,也就是说 entering 里面存储的是渠道,而不是 string。
33 行 case cli := <-entering: 保证了不会阻塞在 52 行。
enter <- ch 做的事情是把这个 ch 作为一个值传递给 enter 这个渠道,而不是取里面的值。
for msg := range ch 才是真正的取 ch 这个渠道的值。
5.
跟4 一样,ch 是作为一个值被传递给 leaving, 而不是取里面的值。
6.
entering leaving 只是作为 tcp 链接的一个中间状态而已,去掉也可以,这是较为熟悉渠道的人做的补充,而对于不太熟悉渠道的就觉得迷惑了。
#2