Golang实现简易聊天室服务与客户端

本文深入浅出地展示了如何用Go语言构建一个轻量、高效且真正并发的简易聊天室系统，核心亮点在于巧妙运用goroutine实现无锁化连接处理、通过joinChan/leaveChan/messageChan三个通道解耦客户端生命周期与消息广播逻辑，避免了传统线程池和显式锁的复杂性；服务器端以net.Listen监听连接、为每个客户端启独立goroutine处理读写，并由专用broadcaster goroutine统一调度消息分发，客户端则用双goroutine分离输入发送与消息接收，确保交互流畅不阻塞——整套方案既体现了Go“用通信共享内存”的并发哲学，又具备极强的可读性与工程实践价值，是理解Go网络编程与并发模型的绝佳入门范例。

一个简单的Golang聊天室客户端与服务器，其核心在于利用Go语言强大的并发特性，通过net包进行网络通信，并借助goroutine和channel来高效地管理多个用户连接和消息传递。服务器端负责监听连接、接收消息并将其广播给所有在线客户端，而客户端则负责建立连接、发送用户输入的消息以及接收并显示服务器广播的消息。

解决方案

说实话，第一次尝试用Go写聊天室，最让我感到惊艳的就是它处理并发的优雅。你不用去操心线程池那些复杂的玩意儿，直接一个go关键字，就能把一个函数扔到独立的执行流里。

服务器端的核心逻辑其实不复杂：

1. 监听端口： 使用net.Listen函数在指定端口上监听传入的TCP连接。
2. 接受连接： 在一个无限循环中，listener.Accept()会阻塞直到有新的客户端连接进来。每接受一个连接，就为这个连接启动一个新的goroutine来处理它。
3. 管理客户端： 这部分有点意思。我们需要一个地方来存放所有活跃的客户端连接，通常是一个map[net.Conn]bool或者map[string]net.Conn。当然，为了并发安全，这个map的操作必须通过sync.Mutex来保护，或者更Go-idiomatic地，通过一个channel来管理客户端的加入和离开事件。我个人更倾向于用channel来传递客户端的加入和离开事件，这样能更好地隔离并发操作。
4. 消息广播： 当一个客户端发送消息到服务器时，服务器收到后，需要将这条消息转发给所有其他在线的客户端。这又是一个并发问题，遍历所有连接并发送消息时，可能会遇到连接断开的情况，所以需要做好错误处理。

客户端这边就相对直白一些：

1. 建立连接： 使用net.Dial连接到服务器的IP地址和端口。
2. 消息发送： 从标准输入（os.Stdin）读取用户输入，然后通过conn.Write发送到服务器。这通常需要一个独立的goroutine来完成，否则会阻塞消息接收。
3. 消息接收： 通过conn.Read持续读取服务器发送过来的消息，并打印到标准输出。这同样需要一个独立的goroutine。

这里我通常会设置一个全局的messageChan（或者叫broadcast channel），所有新连接进来的客户端，都会把它们的消息先扔到这个messageChan里，然后服务器主循环里有一个专门的goroutine负责从这个messageChan里取消息，再发给所有注册的客户端。这样设计，逻辑会清晰很多，也避免了直接在每个客户端goroutine里去遍历所有连接。

代码示例（Server端骨架）:

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "sync"
    "time"
)

// client 结构体代表一个连接到服务器的客户端
type client struct {
    conn     net.Conn
    username string
    // incoming 用于接收来自此客户端的消息（由客户端reader goroutine发送）
    incoming chan string
    // outgoing 用于发送消息给此客户端（由broadcaster goroutine发送）
    outgoing chan string
}

var (
    // clients 存储所有活跃的客户端，用于广播消息
    clients      = make(map[*client]bool)
    mu           sync.Mutex // 保护 clients map 的并发访问
    joinChan     = make(chan *client) // 新客户端加入的通知通道
    leaveChan    = make(chan *client) // 客户端离开的通知通道
    messageChan  = make(chan string)  // 所有客户端发送的消息都会汇聚到这里
)

func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalf("无法监听端口: %v", err)
    }
    defer listener.Close()

    fmt.Println("聊天室服务器已启动，监听端口: 8080")

    go broadcaster() // 启动消息广播器 goroutine

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("接受连接失败: %v", err)
            continue
        }
        go handleConnection(conn) // 为每个新连接启动一个 goroutine 处理
    }
}

// handleConnection 处理单个客户端连接
func handleConnection(conn net.Conn) {
    defer conn.Close() // 确保连接最终被关闭

    // 简单的用户名生成
    username := fmt.Sprintf("匿名用户%d", time.Now().UnixNano()%1000)
    cli := &client{
        conn:     conn,
        username: username,
        incoming: make(chan string),
        outgoing: make(chan string),
    }

    joinChan <- cli // 通知广播器有新客户端加入

    // 启动 goroutine 处理客户端的输入和输出
    go cli.reader() // 从客户端读取消息
    go cli.writer() // 向客户端写入消息

    // 阻塞，直到客户端的reader goroutine关闭incoming channel，表示客户端断开
    // 这是为了让 handleConnection goroutine 保持活跃，直到客户端真正断开
    <-cli.incoming
    leaveChan <- cli // 通知广播器有客户端离开
    log.Printf("客户端 %s (%s) 已断开连接", cli.username, cli.conn.RemoteAddr())
}

// reader goroutine 负责从客户端连接读取消息
func (c *client) reader() {
    scanner := bufio.NewScanner(c.conn)
    for scanner.Scan() {
        msg := scanner.Text()
        messageChan <- fmt.Sprintf("%s: %s", c.username, msg) // 将客户端消息发送到公共消息通道
    }
    // 如果 scanner.Scan() 返回 false，说明客户端断开或发生错误
    close(c.incoming) // 关闭 incoming channel，通知 handleConnection goroutine 客户端已断开
}

// writer goroutine 负责向客户端连接写入消息
func (c *client) writer() {
    for msg := range c.outgoing { // 从 outgoing channel 接收消息
        _, err := fmt.Fprintln(c.conn, msg)
        if err != nil {
            log.Printf("发送消息给 %s 失败: %v", c.username, err)
            return // 写入失败，关闭 writer

本篇关于《Golang实现简易聊天室服务与客户端》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！