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

使用方式

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

接口文档

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

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

执行后,输出结果如下:

  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)。