go 短連線和長連線 超時處理

作為一個可能會和很多Client進行通訊互動的Server，首先要保證的就是整個Server執行狀態的穩定性，因此在和Client建立連線通訊的時候，確保連線的及時斷開非常重要，否則一旦和多個客戶端建立不關閉的長連線，對於伺服器資源的佔用是很可怕的。因此，我們需要針對可能出現的短連線和長連線，設定不同的限制策略。

    針對短連線，我們可以使用golang中的net包自帶的timeout函式，一共有三個，分別是：

[plain] 

view plain  copy

1. func (*IPConn) SetDeadline  
2. func (c *IPConn) SetDeadline(t time.Time) error  
3.   
4. func (*IPConn) SetReadDeadline  
5. func (c *IPConn) SetReadDeadline(t time.Time) error  
6.   
7. func (*IPConn) SetWriteDeadline  
8. func (c *IPConn) SetWriteDeadline(t time.Time) error</span>  

    如果想要給伺服器設定短連線的timeout,我們就可以這麼寫：

[plain]  view plain  copy

1. netListen, err := net.Listen("tcp", Port)  
2.     Log("Waiting for clients")  
3.     for {  
4.         conn, err := netListen.Accept()  
5.         if err != nil {  
6.             continue  
7.         }  
8.   
9.         conn.SetReadDeadline(time.Now().Add(time.Duration(10) * time.Second))</span>  

    這裡的三個函式都是用於設定每次socket連線能夠維持的最長時間，一旦超過設定的timeout後，便會在Server端自動斷開連線。其中SetReadline, SetWriteline設定的是讀取和寫入的最長持續時間，而SetDeadline則同時包含了 SetReadline, SetWriteline兩個函式。

    通過這樣設定，每個和Server通訊的Client連線時長最長也不會超過10s了~~

    搞定短連線後，接下來就是針對長連線的處理策略了~~

    作為長連線，由於我們往往很難確定什麼時候會中斷連線，因此並不能像處理短連線那樣簡單粗暴的設定一個timeout就可以搞定，而在Golang的net包中，並沒有針對長連線的函式，因此需要我們自己設計並實現針對長連線的處理策略啦~

    針對socke長連線，常見的做法是在Server和Socket之間設計通訊機制，當兩者之間沒有資訊互動時，雙方便會定時傳送資料包(心跳)，以維持連線狀態。

    這種方法是目前使用相對比較多的做法，但是開銷相對也較大，特別是當Server和多個client保持長連線的時候，併發會比較高，考慮到公司的業務需求，我最後選擇了邏輯相對簡單，開銷相對較小的策略：

    當Server每次收到Client發到的資訊之後，便會開始心跳計時，如果在心跳計時結束之前沒有再次收到Client發來的資訊，那麼便會斷開跟Client的連線。而一旦在設定時間內再次收到Client發來的資訊，那麼Server便會重置計時器，再次重新進行心跳計時，直到超時斷開連線為止。

下面就是實現該計時的程式碼：

[plain]  view plain  copy

1. //長連線入口  
2. func handleConnection(conn net.Conn,timeout int) {  
3.   
4.     buffer := make([]byte, 2048)  
5.     for {  
6.         n, err := conn.Read(buffer)  
7.   
8.         if err != nil {  
9.             LogErr(conn.RemoteAddr().String(), " connection error: ", err)  
10.             return  
11.         }  
12.         Data :=(buffer[:n])  
13.         messnager := make(chan byte)  
14.         postda :=make(chan byte)  
15.         //心跳計時  
16.         go HeartBeating(conn,messnager,timeout)  
17.         //檢測每次Client是否有資料傳來  
18.         go GravelChannel(Data,messnager)  
19.         Log( "receive data length:",n)  
20.         Log(conn.RemoteAddr().String(), "receive data string:", string(Data  
21.   
22.     }  
23. }  
24.   
25. //心跳計時，根據GravelChannel判斷Client是否在設定時間內發來資訊  
26. func HeartBeating(conn net.Conn, readerChannel chan byte,timeout int) {  
27.         select {  
28.         case fk := <-readerChannel:  
29.             Log(conn.RemoteAddr().String(), "receive data string:", string(fk))  
30.             conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))  
31.             //conn.SetReadDeadline(time.Now().Add(time.Duration(5) * time.Second))  
32.             break  
33.         case <-time.After(time.Second*5):  
34.             Log("It's really weird to get Nothing!!!")  
35.             conn.Close()  
36.         }  
37.   
38. }  
39.   
40. func GravelChannel(n []byte,mess chan byte){  
41.     for _ , v := range n{  
42.         mess <- v  
43.     }  
44.     close(mess)  
45. }  
46.   
47.   
48. func Log(v ...interface{}) {  
49.     log.Println(v...)  
50. }  

    這樣，就可以成功實現對於長連線的處理了~~，我們可以這麼進行測試：

[plain]  view plain  copy

1. func sender(conn net.Conn) {  
2.     for i := 0; i <5; i++ {  
3.         words:= strconv.Itoa(i)+"This is a test for long conn"   
4.         conn.Write([]byte(words))  
5.         time.Sleep(2*time.Second)  
6.   
7.     }  
8.     fmt.Println("send over")  
9.   
10. }  

    可以發現，Sender函式中time.Sleep阻塞的時間設定的比Server中的timeout短的時候，Client端的資訊可以自由的傳送到迴圈結束，而當我們設定Sender函式的阻塞時間較長時，就只能發出第一次迴圈的資訊。