检索 Go 中 Transport 的连接总数

**首段摘要：** 在 Go 中实现负载平衡算法时，经常需要监控后端连接数以实现最少连接策略。然而，标准库中没有提供获取传输层连接数量的方法。本文介绍了一种通过包装 DialContext 字段来获取连接数的方法，同时还提供了其他算法和示例代码，以帮助开发人员在 Go 中实现最少连接负载平衡。

我正在 Go 中实现反向代理的负载平衡算法。

当然，循环很简单，但我正在努力实现最少连接。

我找不到检查从代理到后端的连接数量的方法。

有没有办法从传输或任何其他底层结构获取打开连接的数量？

解决方案

您可以将 dialcontext 的字段包装在 *http.transport 中，以获取 transport 的打开连接数。

这是我的示例代码：https://gist.github.com/HattieWebb/2000c514b37a6a0bb5e8b55fadbe3433

// do not support if dialtls is set.
func newtransportwithconnectnum(old *http.transport) *transport{
    connectcounter:=&connectcounter_t{}
    tran:=&transport{
        transport:        old,
        connectcounter: connectcounter,
    }
    olddialer:=tran.getolddialer()
    tran.transport.dialcontext = func(ctx context.context, network, addr string) (net.conn, error){
        conn1,err:=olddialer(ctx,network,addr)
        if err!=nil{
            return nil,err
        }
        connectcounter.add(1)
        conn2:=&connwithcounter{
            conn: conn1,
            connectcounter: connectcounter,
        }
        return conn2,nil
    }
    return tran
}

type transport struct{
    *http.transport
    connectcounter *connectcounter_t
}

func (tran *transport) getconnectionnum() int{
    return tran.connectcounter.get()
}

var zerodialer net.dialer

func (tran *transport) getolddialer() func(ctx context.context, network, addr string) (net.conn, error){
    if tran.dialcontext!=nil{
        return tran.dialcontext
    }
    if tran.dial!=nil{
        return func(ctx context.context, network, addr string) (net.conn, error){
            return tran.dial(network,addr)
        }
    }
    return zerodialer.dialcontext
}

type connectcounter_t struct{
    connectnum int
    connectnumlocker sync.mutex
}

func (c *connectcounter_t) add(num int){
    c.connectnumlocker.lock()
    c.connectnum+=num
    c.connectnumlocker.unlock()
}
func (c *connectcounter_t) get()(num int){
    c.connectnumlocker.lock()
    num = c.connectnum
    c.connectnumlocker.unlock()
    return num
}

type connwithcounter struct{
    net.conn
    closecountersynconce sync.once
    connectcounter *connectcounter_t
}

func (conn *connwithcounter) close() (err error){
    err = conn.conn.close()
    conn.closecountersynconce.do(func(){
        conn.connectcounter.add(-1)
    })
    return err
}

您可以尝试查看 hlts2/least-connections，一个用 golang 编写的最少连接平衡算法。

示例：

lc, err := new([]*url.url{
    {host: "192.168.33.10"},
    {host: "192.168.33.11"},
    {host: "192.168.33.12"},
})

src1, done1 := lc.next() // {host: "192.168.33.10"}

src2, done2 := lc.next() // {host: "192.168.33.11"}

done1() // reduce connection of src1

src3, done3 := lc.next() // {host: "192.168.33.10"}

它确实使用了 sync.Mutex

type leastconnections struct {
    conns []conn
    mu    *sync.mutex
}

另一个更复杂的示例：panjf2000/gnet 在“发布 go 的高性能轻量级事件循环网络库”中介绍，作者：Andy Pan。

Example

    // start a server
    // connect 10 clients
    // each client will pipe random data for 1-3 seconds.
    // the writes to the server will be random sizes. 0kb - 1mb.
    // the server will echo back the data.
    // waits for graceful connection closing.
    t.run("poll", func(t *testing.t) {
        t.run("tcp", func(t *testing.t) {
            t.run("1-loop", func(t *testing.t) {
                testserve("tcp", ":9991", false, false, false, 10, roundrobin)
            })
            t.run("n-loop", func(t *testing.t) {
                testserve("tcp", ":9992", false, true, false, 10, leastconnections)
            })
        })

再次，structure is straightforward：

    // leastConnectionsEventLoopSet with Least-Connections algorithm.
    leastConnectionsEventLoopSet struct {
        sync.RWMutex
        minHeap                 minEventLoopHeap
        cachedRoot              *eventloop
        threshold               int32
        calibrateConnsThreshold int32
    }

本篇关于《检索 Go 中 Transport 的连接总数》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！