golang开发的工程经验积累（一）

1，自定义结构体维护用户和对应的tcp链接
可以使用map来维护这个信息，但这样一旦连接的用户数目较多，则map会过大而降低查询的效率，所以可以自定义结构体：

type User struct {
    uid          int64
    conn       *CConn
    ticked      bool // 多次连接导致当前连接被踢下
    beatTimeOut    bool // 心跳检测超时
    ...
}

type CConn struct{
    conn      net.Conn  // 网络连接
    lastTime time.Time  // 最近一次通信时间
    addr       string  // 连接的唯一标识符
    user       *User // User与CConn一一映射
}

然后在建立连接时

func CListenAndServe(net, addr string) {
    tcpAddr, err := net.ResolveTCPAddr(net,addr)
    if err != nil {
        // error handling
    }
    listener, err := net.listenTCP(net, tcpAddr)
    if err != nil {
        //error handling
    }
    go accept() //因为go协程的创建开销非常小
}

func accpet() {
    for {
        conn, err := listener.AcceptTCP()
        if err == nil {
            // 发包频率统计，避免频繁连接
            // 黑白名单
            newconn := NewCConn(conn) // 创建CConn
            newconn.Run()
        } else {
            // error handling
        }
    }
}

func (conn *CConn) Run() {
    conn.onConnect()
    go func() {
        tickerRecv := time.NewTicker(time.Second * time.Duration(rateStatInterval))
        for {
            select {
            case <- conn.StopChan:
                tickerRecv.Stop()
                return
            case <- tickerRecv.c:
                conn.packetRecv = 0
            default:
                conn_closed := conn.parseAndHandlePdu()
                if conn_closed{
                    tickerRecv.Stop()
                    return
                }
            }
        }
    }()
}

func (conn *CConn) onConnect() *User {
    user := &User{conn:conn, ... // 其他初始化内容}
}

每个连接都用一个go协程来处理，这样就能将每个连接都独立起来，当然还需要注意一点，每个服务节点的连接数应该有限时策略。

2，拿来即用的单例模式

import  "github.com/dropbox/godropbox/singleton"
var singleSrv = singleton.NewSingleton(func() (interface{}, error) {
    cluster, _ := cache.GetRedisCluster("singlecache")
    return &SingleMsgProxy{
        Cluster: cluster,
        MsgModel: msg.MsgModel,
    }, nil
})

3，泛型

type MyInterface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}
func CustomSort(d MyInterface) {
    ...
}

不管使用CustomeSort的d是什么类型，只要按照接口的要求实现了Len() Less() Swap()就可以使用CustomSort函数。

4，当定义的struct中存在map或者slice时，一定注意这两者是引用
如
type MyObject struct {
olist []string
}

func (m *MyObject) SetList(src []string) {
m.olist = src
}
如果传入之后，你再对src进行变更，那么MyObject中的olist也会受到影响，
正确的做法应该使用copy。

5，go实现并发非常容易，但不要因此滥用。
遇到要做的事情，直接go someFunc()，当go协程创建后，就由底层进行调度，这时我们便失去了对这些执行体的控制。
所以要么使用管道传递信号，要么使用context包，推荐使用后者来构建一个调用链，可以从外层终止go程（go程内部使用for select 监听）