• 示例1，基本使用
  • 示例2，连接断开情况

    gtcp模块提供了连接池的特性，由gtcp.PoolConn对象实现，连接池缓存固定存活时间为600秒，且内部实现了数据发送时的断开重连机制。连接池非常适合于频繁的短链接操作且连接并发量大的场景。我们接下来使用两个示例来演示一下连接池的作用。

    使用方式：

    1. import "github.com/gogf/gf/g/net/gtcp"

    接口文档：

    https://godoc.org/github.com/gogf/gf/g/net/gtcp

    1. type PoolConn
    2.     func NewPoolConn(addr string, timeout ...int) (*PoolConn, error)
    3.     func (c *PoolConn) Close() error
    4.     func (c *PoolConn) Recv(length int, retry ...Retry) ([]byte, error)
    5.     func (c *PoolConn) RecvLine(retry ...Retry) ([]byte, error)
    6.     func (c *PoolConn) RecvPkg(option ...PkgOption) ([]byte, error)
    7.     func (c *PoolConn) RecvPkgWithTimeout(timeout time.Duration, option ...PkgOption) ([]byte, error)
    8.     func (c *PoolConn) RecvWithTimeout(length int, timeout time.Duration, retry ...Retry) (data []byte, err error)
    9.     func (c *PoolConn) Send(data []byte, retry ...Retry) error
    10.     func (c *PoolConn) SendPkg(data []byte, option ...PkgOption) (err error)
    11.     func (c *PoolConn) SendPkgWithTimeout(data []byte, timeout time.Duration, option ...PkgOption) error
    12.     func (c *PoolConn) SendRecv(data []byte, receive int, retry ...Retry) ([]byte, error)
    13.     func (c *PoolConn) SendRecvPkg(data []byte, option ...PkgOption) ([]byte, error)
    14.     func (c *PoolConn) SendRecvPkgWithTimeout(data []byte, timeout time.Duration, option ...PkgOption) ([]byte, error)
    15.     func (c *PoolConn) SendRecvWithTimeout(data []byte, receive int, timeout time.Duration, retry ...Retry) ([]byte, error)
    16.     func (c *PoolConn) SendWithTimeout(data []byte, timeout time.Duration, retry ...Retry) error

    由于gtcp.PoolConn继承于gtcp.Conn因此同时也可以使用gtcp.Conn的方法。

    示例1，基本使用

    1. package main
    3. import (
    4.     "fmt"
    5.     "time"
    6.     "github.com/gogf/gf/g/net/gtcp"
    7.     "github.com/gogf/gf/g/os/glog"
    8.     "github.com/gogf/gf/g/os/gtime"
    9. )
    11. func main() {
    12.     // Server
    13.     go gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
    14.         defer conn.Close()
    15.         for {
    16.             data, err := conn.Recv(-1)
    17.             if len(data) > 0 {
    18.                 if err := conn.Send(append([]byte("> "), data...)); err != nil {
    19.                     fmt.Println(err)
    20.                 }
    21.             }
    22.             if err != nil {
    23.                 break
    24.             }
    25.         }
    26.     }).Run()
    28.     time.Sleep(time.Second)
    30.     // Client
    31.     for {
    32.        if conn, err := gtcp.NewPoolConn("127.0.0.1:8999"); err == nil {
    33.            if b, err := conn.SendRecv([]byte(gtime.Datetime()), -1); err == nil {
    34.                fmt.Println(string(b), conn.LocalAddr(), conn.RemoteAddr())
    35.            } else {
    36.                fmt.Println(err)
    37.            }
    38.            conn.Close()
    39.        } else {
    40.            glog.Error(err)
    41.        }
    42.        time.Sleep(time.Second)
    43.     }
    44. }

    在这个示例中，Server创建新的goroutine异步运行，Client在main goroutine中执行。Server端是一个回显服务器，Client每隔1秒向Server端发送当前的时间，经过Server端回显返回后，在Client端打印出双方的连接端口信息。

    执行后，结果如下：

    1. > 2018-07-11 23:29:54 127.0.0.1:55876 127.0.0.1:8999
    2. > 2018-07-11 23:29:55 127.0.0.1:55876 127.0.0.1:8999
    3. > 2018-07-11 23:29:56 127.0.0.1:55876 127.0.0.1:8999
    4. > 2018-07-11 23:29:57 127.0.0.1:55876 127.0.0.1:8999
    5. > 2018-07-11 23:29:58 127.0.0.1:55876 127.0.0.1:8999
    6. ...

    可以看到，Client的端口一直未变，每一次通过gtcp.NewConn("127.0.0.1:8999")获得的都是同一个gtcp.Conn对象，且每一次conn.Close()时并不是真正的关闭连接，而是将该对象重新丢回到连接池里循环使用。

    示例2，连接断开情况

    这个例子是为了展示当服务端关闭连接后，该连接对象还是否有效的处理。

    1. package main
    3. import (
    4.     "fmt"
    5.     "time"
    6.     "github.com/gogf/gf/g/net/gtcp"
    7.     "github.com/gogf/gf/g/os/glog"
    8.     "github.com/gogf/gf/g/os/gtime"
    9. )
    11. func main() {
    12.     // Server
    13.     go gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
    14.         defer conn.Close()
    15.         for {
    16.             data, err := conn.Recv(-1)
    17.             if len(data) > 0 {
    18.                 if err := conn.Send(append([]byte("> "), data...)); err != nil {
    19.                     fmt.Println(err)
    20.                 }
    21.             }
    22.             if err != nil {
    23.                 break
    24.             }
    25.             return
    26.         }
    27.     }).Run()
    29.     time.Sleep(time.Second)
    31.     // Client
    32.     for {
    33.        if conn, err := gtcp.NewPoolConn("127.0.0.1:8999"); err == nil {
    34.            if b, err := conn.SendRecv([]byte(gtime.Datetime()), -1); err == nil {
    35.                fmt.Println(string(b), conn.LocalAddr(), conn.RemoteAddr())
    36.            } else {
    37.                fmt.Println(err)
    38.            }
    39.            conn.Close()
    40.        } else {
    41.            glog.Error(err)
    42.        }
    43.        time.Sleep(time.Second)
    44.     }
    45. }

    执行后，输出结果如下：

    1. > 2018-07-20 12:56:15 127.0.0.1:59368 127.0.0.1:8999
    2. EOF
    3. > 2018-07-20 12:56:17 127.0.0.1:59376 127.0.0.1:8999
    4. EOF
    5. > 2018-07-20 12:56:19 127.0.0.1:59378 127.0.0.1:8999
    6. EOF
    7. ...

    在这个示例中，Server每处理完毕一条请求之后便关闭链接。Client在第一条请求发送完毕后，由于连接池的IO复用特性，下一次获取到的将是同一个连接对象，由于Server链接已主动关闭，第二次请求写入成功（其实并未成功发送到Server端，需要通过下一次的读取操作才能检测到链接错误），但是读取却失败了（EOF表示目标连接关闭），因此这个时候Client执行Close时将会销毁该连接操作对象，而不是进一步复用。下一次再通过gtcp.NewPoolConn获得连接对象时，Client将会与Server创建一个新的连接进行数据通信。所以你看到Client的端口一直在变化，那是因为该gtcp.Conn对象已经是一个新的连接对象，之前的连接对象已经被销毁。

    连接对象的IO复用涉及到十分微妙的连接状态变化问题，由于点对点网络通信本身是比较复杂的环境，连接对象的状态随时可能被动发生着变化，因此，在使用gtcp连接池特性时，需要注意当通信错误产生时的连接对象重建机制，一旦产生错误，立即丢弃（Close）该对象(gtcp.PoolConn)并重建（gtcp.NewPoolConn）。