首页 > Go语言 > Go语言并发 阅读:1,558

Go语言聊天服务器

本节将带领大家结合咱们前面所学的知识开发一个聊天的小程序,它可以在几个用户之间相互广播文本消息。这个程序里包含 4 个 goroutine。主 goroutine 和广播(broadcaster)goroutine,每一个连接里面有一个连接处理(handleConn)goroutine 和一个客户写入(clientwriter)goroutine。

广播器(broadcaster)是关于如何使用 select 的一个规范说明,因为它需要对三种不同的消息进行响应。

如下所示,主 goroutine 的工作是监听端口,接受连接客户端的网络连接。对每一个连接,它创建一个新的 handleConn goroutine。
package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
)
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)
    }
}
下一个是广播器,它使用局部变量 clients 来记录当前连接的客户集合。每个客户唯一被记录的信息是其对外发送消息通道的 ID,下面是细节:
type client chan<- string // 对外发送消息的通道

var (
    entering = make(chan client)
    leaving  = make(chan client)
    messages = make(chan string) // 所有连接的客户端
)

func broadcaster() {
    clients := make(map[client]bool) // all connected clients
    for {
        select {
        case msg := <-messages:
            // 把所有接收到的消息广播给所有客户端
            // 发送消息通道
            for cli := range clients {
                cli <- msg
            }

        case cli := <-entering:
            clients[cli] = true

        case cli := <-leaving:
            delete(clients, cli)
            close(cli)
        }
    }
}
广播者监听两个全局的通道 entering 和 leaving,通过它们通知客户的到来和离开,如果它从其中一个接收到事件,它将更新 clients 集合。如果客户离开,那么它关闭对应客户对外发送消息的通道。

广播者也监听来自 messages 通道的事件,所有的客户都将消息发送到这个通道。当广播者接收到其中一个事件时,它把消息广播给所有客户。

现在来看一下每个客户自己的 goroutine。handleConn 函数创建一个对外发送消息的新通道,然后通过 entering 通道通知广播者新客户到来。

接着,它读取客户发来的每一行文本,通过全局接收消息通道将每一行发送给广播者,发送时在每条消息前面加上发送者 ID 作为前缀。一旦从客户端读取完毕消息,handleConn 通过 leaving 通道通知客户离开,然后关闭连接。
func handleConn(conn net.Conn) {
    ch := make(chan string) // 对外发送客户消息的通道
    go clientWriter(conn, ch)

    who := conn.RemoteAddr().String()
    ch <- "You are " + who
    messages <- who + " has arrived"
    entering <- ch

    input := bufio.NewScanner(conn)
    for input.Scan() {
        messages <- who + ": " + input.Text()
    }
    // 注意:忽略 input.Err() 中可能的错误

    leaving <- ch
    messages <- who + " has left"
    conn.Close()
}

func clientWriter(conn net.Conn, ch <-chan string) {
    for msg := range ch {
        fmt.Fprintln(conn, msg) // 注意:忽略网络层面的错误
    }
}
另外,handleConn 函数还为每一个客户创建了写入(clientwriter)goroutine,它接收消息,广播到客户的发送消息通道中,然后将它们写到客户的网络连接中。客户写入者的循环在广播者收到 leaving 通知并且关闭客户的发送消息通道后终止。

下面的信息展示了同一个机器上的一个服务器和两个客户端,它们使用 netcat 程序来聊天:

$ go build gopl.io/ch8/main
$ go build gopl.io/ch8/netcat

$ ./main &
$ ./netcat
You are 127.0.0.1:64208                     $ ./netcat
127.0.0.1:64211 has arrived                You are 127.0.0.1:64211
Hi!
127.0.0.1:64208: Hi!                         127.0.0.1:64208: Hi!
                                                            Hi yourself.
127.0.0.1:64211: Hi yourself.              127.0.0.1:64211: Hi yourself.
^C
                                                           127.0.0.1:64208 has left
$ ./netcat
You are 127.0.0.1:64216                    127.0.0.1:64216 has arrived
                                                           Welcome.
127.0.0.1:64211: Welcome.                127.0.0.1:64211: Welcome.
                                                           ^C
127.0.0.1:64211 has left

netcat 的完整代码如下所示:
// netcat.go
// netcat是一个简单的TCP服务器读/写客户端
package main

import (
    "io"
    "log"
    "net"
    "os"
)

func main() {
    conn, err := net.Dial("tcp", "localhost:8000")
    if err != nil {
        log.Fatal(err)
    }
    done := make(chan struct{})
    go func() {
        io.Copy(os.Stdout, conn) // 注意:忽略错误
        log.Println("done")
        done <- struct{}{} // 向主Goroutine发出信号
    }()
    mustCopy(conn, os.Stdin)
    conn.Close()
    <-done // 等待后台goroutine完成
}

func mustCopy(dst io.Writer, src io.Reader) {
    if _, err := io.Copy(dst, src); err != nil {
        log.Fatal(err)
    }
}
当有 n 个客户 session 在连接的时候,程序并发运行着 2n+2 个相互通信的 goroutine,它不需要隐式的加锁操作。clients map 限制在广播器这一个 goroutine 中被访问,所以不会并发访问它。唯一被多个 goroutine 共享的变量是通道以及 net.Conn 的实例,它们又都是并发安全的。

编程帮,一个分享编程知识的公众号。跟着站长一起学习,每天都有进步。

通俗易懂,深入浅出,一篇文章只讲一个知识点。

文章不深奥,不需要钻研,在公交、在地铁、在厕所都可以阅读,随时随地涨姿势。

文章不涉及代码,不烧脑细胞,人人都可以学习。

当你决定关注「编程帮」,你已然超越了90%的程序员!

编程帮二维码
微信扫描二维码关注