看了两天 go 语言，是时候练练手了。
go 的 routine（例程） 和 chan（通道） 简直是神器，实现多线程（在 go 里准确的来说是 多例程）简直不要太轻松。

于是动手码了一个傻瓜版的黑框聊天器。

server 端：
监听 TCP 连接；支持自定义客户端命令；支持消息分发；理论上支持广播；…

package main

import (
    "fmt"
    "net"
    "io"
    "strconv"
    "time"
    "strings"
)

const (
    NORMAL_MESSAGE = iota
    LIST_MESSAGE
)

var clientSenders = make(map[string] chan string)

func send (addr string, conn *net.Conn){
    senderChan := clientSenders[addr]
    for s := range senderChan{
        (*conn).Write([]byte(s))
    }
}

func sendUsersInfo(addr string){
    senderChan := clientSenders[addr]
    if nil != senderChan{
        ls := strconv.Itoa(LIST_MESSAGE)
        cs := strconv.Itoa(NORMAL_MESSAGE) + "已登录客户端列表：\n"
        i := 1
        for k := range clientSenders{
            a := ""
            if k == addr {
                a = "（我）"
            }
            cs = cs + strconv.Itoa(i) + "）"  + k + a + "\n"
            ls += k + "\n"
            i ++
        }
        cs += "发送消息，可使用 1<-这是给1号客户端的消息\n（请使用英文以获取最佳体验）\n"

        senderChan <- cs
        time.Sleep(time.Millisecond * 300)
        senderChan <- ls

        // 发送格式化的列表

        fmt.Println("已发送“登录用户信息”", addr)
    } else{
        fmt.Println("客户端接受通道不存在", addr)
    }
}

func serve (conn *net.Conn){
    connect := *conn

    addr := connect.RemoteAddr().String()

    fmt.Println(addr, "接入服务")

    senderChan := make(chan string, 3)
    clientSenders[addr] = senderChan

    // 启动发送
    go send(addr, conn)

    // 发送当前用户信息
    go sendUsersInfo(addr)

    buff := make([]byte, 10240)
    for {
        n, err := connect.Read(buff)
        if err != nil {
            if err == io.EOF {
                fmt.Println("客户端断开链接，", addr)
                delete(clientSenders, addr)
                return
            } else{
                fmt.Println(err)
            }
        }

        msg := string(buff[:n])

        // 刷新客户端列表
        if msg == "ls\n" {
            go sendUsersInfo(addr)
            continue
        }

        // 提取数据
        msgs := strings.Split(msg, "<-")
        if len(msg) < 2{
            senderChan <- string("数据格式不正确，请联系开发者")
            continue
        }

        aimAddr := msgs[0]
        aimSender := clientSenders[aimAddr]
        if aimSender == nil {
            senderChan <- string("客户端已下线，使用 ls 命令获取最新的客户端列表")
            continue
        }

        aimSender <- strconv.Itoa(NORMAL_MESSAGE) + "[from:" + addr + "]:" + strings.Join(msgs[1:], "<-")
    }
}

func main(){
    addr := ":8080"
    listener, err := net.Listen("tcp", addr)
    if err != nil{
        fmt.Println(err)
        return
    }

    // 启动消息调度器

    defer listener.Close()

    // 启动连接监听
    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println(err)
            continue
        }

        go serve(&conn)
    }
}

客户端：
支持断线重连；支持给特定其他客户端发信息

package main

import (
    "net"
    "fmt"
    "io"
    "os"
    "bufio"
    "sync"
    "time"
    "strings"
    "strconv"
)


var conn *net.Conn
var addrs []string

const (
    NORMAL_MESSAGE = iota
    LIST_MESSAGE
)

func read(conn2 *net.Conn){
    defer func() {
        fmt.Println("尝试重连")
        go connectServer()
    }()

    connect := *conn2
    buff := make([]byte, 20140)
    for {
        n, err := connect.Read(buff)
        if err != nil {
            if err == io.EOF{
                fmt.Println("结束")
                (*conn2).Close()
                conn = nil
                return
            } else{
                fmt.Println(err)
            }
        }

        msg := string(buff[:n])
        t, err := strconv.Atoi(string(msg[0]))
        msg = msg[1:]

        switch t {
        case NORMAL_MESSAGE:
            fmt.Print(msg)
            break
        case LIST_MESSAGE:
            // 解析客户端列表数据
            addrs = strings.Split(msg, "\n")
            fmt.Println("已接收客户端列表。\n")
            break
        default:
            fmt.Print(msg)
            break
        }
    }
}

func connectServer(){
    addr := "192.168.99.236:8080"
    fmt.Println("等待服务器开启中")
    conn2, err := net.Dial("tcp", addr)
    if err != nil {
        fmt.Print(err)
        fmt.Println("连接失败，10s后尝试")
        time.Sleep(10 * time.Second)
        go connectServer()
        return
    }

    fmt.Println("已连接")

    conn = &conn2
    go read(&conn2)
}

func send (){
    inputReader := bufio.NewReader(os.Stdout)
    for {
        input, err := inputReader.ReadString('\n')
        if err != nil {
            if err == io.EOF{
                return
            } else{
                fmt.Println(err)
            }
        }

        if input == "ls\n" {
            (*conn).Write([]byte(input))
            continue
        }

        msgs := strings.Split(input, "<-")
        if len(msgs) < 2 {
            fmt.Println("发送的姿势不正确，应该像这样 1<-给1号发送消息\n")
            continue
        }

        index, err := strconv.Atoi(msgs[0])
        if err != nil {
            fmt.Println("发送的姿势不正确，应该像这样 1<-给1号发送消息\n")
            continue
        }

        if len(addrs) <= index {
            fmt.Println("不存在第" + strconv.Itoa(index) + "个客户端\n")
            continue
        }

        addr := addrs[index-1]

        input = addr + "<-" + strings.Join(msgs[1:], "<-")

        if nil != conn {
            (*conn).Write([]byte(input))
        }
    }
}

func main (){
    var wg sync.WaitGroup
    wg.Add(2)
    go connectServer()
    go send()
    wg.Wait()

    defer func() {
        if nil != conn {
            (*conn).Close()
        }
    }()
}