qps tcp有吗_golang server epoll client 使用连接池 15万+ qps

epoll 加连接池

前几天看了epoll 使用，今天写了一个测试脚本，测试一下epoll加连接池的性能

50万个请求，连接池使用2000连接，发送 "test" 服务端接受后 转成大写返回，处理完所有的请求耗时3.731506996s，性能很强大(注意：需要在linux环境下测试)

为什么要使用连接池？

拿数据库举例，频繁的建立、关闭连接，会极大的降低mysql的性能，因为建立连接，释放连接引起的大量性能开销。

连接池技术带来的优势：

1、资源重用

由于tcp得到重用，避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增进了系统运行环境的平稳性(减少内存碎片以及数据库临时进程/线程的数量)。

2、更快的系统响应速度

连接池在初始化后运行中。对于业务请求处理而言，大部分请求可以直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。

3、连接数量的控制

过多的连接数量会拖垮整个服务，连接池可以设定activeConne连接数量，从客户端阻塞过多的连接，保证系统服务的平稳。

4、统一的连接管理，避免数据库连接泄漏

根据预先的连接占用超时设定，强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄漏。

为什么使用epoll

首先对于一个tcp连接，操作系统会为每一个连接分配一定的内存空间外(主要是内部网络数据结构sk_buff的大小、连接的读写缓存，sof),虽然这些可以进行调优，但是如果想使用正常的操作系统的TCP/IP栈的话，这些是硬性的需求。刨去这些，不同的编程语言不同的框架的设计，甚至是不同的需求场景，都会极大的影响TCP服务器内存的占用和处理。

一般Go语言的TCP(和HTTP)的处理都是每一个连接启动一个goroutine去处理，因为我们被教导goroutine的不像thread, 它是很便宜的，可以在服务器上启动成千上万的goroutine。但是对于一百万的连接，这种goroutine-per-connection的模式就至少要启动一百万个goroutine，这对资源的消耗也是极大的。针对不同的操作系统和不同的Go版本，一个goroutine锁使用的最小的栈大小是2KB ~ 8 KB (go stack),如果在每个goroutine中在分配byte buffer用以从连接中读写数据，几十G的内存轻轻松松就分配出去了。

在linux测试过epoll性能，5万个tcp连接

1、client端

func main() {

connections:=50000

addr:="127.0.0.1:8972"

var conns []net.Conn

for i := 0; i < connections; i++ {

c, err := net.DialTimeout("tcp", addr, 10*time.Second)

if err != nil {

fmt.Println("failed to connect", i, err)

i--

continue

}

conns = append(conns, c)

time.Sleep(time.Millisecond)

}

defer func() {

for _, c := range conns {

c.Close()

}

}()

log.Printf("完成初始化 %d 连接", len(conns))

tts := time.Millisecond * 5

for {

for i := 0; i < len(conns); i++ {

time.Sleep(tts)

conn := conns[i]

conn.Write([]byte("hello world\r\n"))

}

}

}

2、普通的tcp连接

server.go

func main() {

ln, err := net.Listen("tcp", "127.0.0.1:8972")

if err != nil {

panic(err)

}

var connections []net.Conn

defer func() {

for _, conn := range connections {

conn.Close()

}

}()

for {

conn, e := ln.Accept()

if e != nil {

if ne, ok := e.(net.Error); ok && ne.Temporary() {

log.Printf("accept temp err: %v", ne)

continue

}

log.Printf("accept err: %v", e)

return

}

go handleConn(conn)

connections = append(connections, conn)

if len(connections)%100 == 0 {

log.Printf("total number of connections: %v", len(connections))

}

}

}

func handleConn(conn net.Conn) {

io.Copy(ioutil.Discard, conn)

}

5万个tcp消耗的内存情况

3、epoll 使用的是【百万 Go TCP 连接的思考: epoll方式减少资源占用】该博客的epoll的代码

5万个tcp消耗的内存情况

下面使用连接池加epoll测试 qps 15万+

使用连接池，server使用epoll，使用2000个连接，处理完50万个请求，发送test ，返回TEST大写，耗时3.7s，处理完所有的请求，qps 15万+

github上有详细代码，地址：https://github.com/shanlongpa...

1、testPool.go是client端代码

testPoll.go 是连接池的使用

pool := &pools.Pool{

MaxIdle: 100,

MaxActive: 2000,

IdleTimeout: 20 * time.Second,

MaxConnLifetime: 100 * time.Second,

Dial: func() (net.Conn, error) {

c, err := net.Dial("tcp", "127.0.0.1:8972")

if err != nil {

return nil, err

}

return c, err

},

}

defer pool.Close()

t := time.Now()

worklist := make(chan int)

var wg sync.WaitGroup

for i := 0; i < 2000; i++ {

go func() {

for range worklist {

wg.Done()

cli,err:=pool.Get()

if err!=nil{

log.Println(err)

return

}

str:="test"

err=pools.Write(cli.C,[]byte(str))

if err!=nil{

log.Println(err)

pool.Put(cli,true)

return

}

_,err=pools.Read(cli.C)

if err!=nil{

log.Println(err)

}else{

//if i%500==0{

// fmt.Println(string(receByte))

//}

}

pool.Put(cli,false)

}

}()

}

for i := 0; i < 500000; i++ {

wg.Add(1)

worklist

}

fmt.Println("pool建立，连接数：",pool.Active)

close(worklist)

wg.Wait()

// 调用服务

fmt.Println(time.Since(t))

-连接池结构

type Pool struct {

// 建立tcp连接

Dial func() (net.Conn, error)

// 健康检测，判断连接是否断开

TestOnBorrow func(c net.Conn, t time.Time) error

// 连接池中最大空闲连接数

MaxIdle int

// 打开最大的连接数

MaxActive int

// Idle多久断开连接，小于服务器超时时间

IdleTimeout time.Duration

// 配置最大连接数的时候，并且wait是true的时候，超过最大的连接，get的时候会阻塞，知道有连接放回到连接池

Wait bool

// 超过多久时间 链接关闭

MaxConnLifetime time.Duration

chInitialized uint32 // set to 1 when field ch is initialized 原子锁ch初始化一次

mu sync.Mutex // 锁

closed bool // set to true when the pool is closed.

Active int // 连接池中打开的连接数

ch chan struct{} // limits open connections when p.Wait is true

Idle idleList // idle 连接

}

// 空闲连，记录poolConn的头和尾

type idleList struct {

count int

front, back *poolConn

}

// 连接的双向链表

type poolConn struct {

C net.Conn

t time.Time // idle 时间，即放会pool的时间

created time.Time //创建时间

next, prev *poolConn

}

主要有两个方法Get(),获取一个可用的连接。 Put() 把连接放回到连接池

func (p *Pool) Get() (*poolConn, error) {

// p.Wait == true. 的时候限制最大连接数

if p.Wait && p.MaxActive > 0 {

p.lazyInit()

}

p.mu.Lock()

// 删除idle超时的连接，删除掉

if p.IdleTimeout > 0 {

n := p.Idle.count

for i := 0; i < n && p.Idle.back != nil && p.Idle.back.t.Add(p.IdleTimeout).Before(nowFunc()); i++ {

pc := p.Idle.back

p.Idle.popBack()

p.mu.Unlock()

pc.C.Close()

p.mu.Lock()

p.Active--

}

}

//从Idle list 获取一个可用的空闲链接.

for p.Idle.front != nil {

pc := p.Idle.front

p.Idle.popFront()

p.mu.Unlock()

if (p.TestOnBorrow == nil || p.TestOnBorrow(pc.C, pc.t) == nil) &&

(p.MaxConnLifetime == 0 || nowFunc().Sub(pc.created) < p.MaxConnLifetime) {

return pc, nil

}

pc.C.Close()

p.mu.Lock()

p.Active--

}

//pool关闭后直接return error

if p.closed {

p.mu.Unlock()

return nil, errors.New("get on closed pool")

}

// Handle limit for p.Wait == false.

if !p.Wait && p.MaxActive > 0 && p.Active >= p.MaxActive {

p.mu.Unlock()

return nil, errors.New("pool 耗尽了")

}

p.Active++

p.mu.Unlock()

c, err := p.Dial()

if err != nil {

c = nil

p.mu.Lock()

p.Active--

if p.ch != nil && !p.closed {

p.ch

}

p.mu.Unlock()

}

return &poolConn{C: c, created: nowFunc()}, err

}

func (p *Pool) Put(pc *poolConn, forceClose bool) error {

p.mu.Lock()

if !p.closed && !forceClose {

pc.t = nowFunc()

p.Idle.pushFront(pc)

if p.Idle.count > p.MaxIdle {

pc = p.Idle.back

p.Idle.popBack()

} else {

pc = nil

}

}

if pc != nil {

p.mu.Unlock()

pc.C.Close()

p.mu.Lock()

p.Active--

}

if p.ch != nil && !p.closed {

p.ch

}

p.mu.Unlock()

return nil

}

2、epollServer.go 是服务端代码

epoll 使用主要分为三部，第一步创建epoll，第二部，添加事件 EPOLL_CTL_ADD，第三步，等待EpollEvent.

func main() {

setLimit()

ln, err := net.Listen("tcp", "127.0.0.1:8972")

if err != nil {

panic(err)

}

epoller, err = MkEpoll()

if err != nil {

panic(err)

}

go start()

for {

conn, e := ln.Accept()

if e != nil {

if ne, ok := e.(net.Error); ok && ne.Temporary() {

log.Printf("accept temp err: %v", ne)

continue

}

log.Printf("accept err: %v", e)

return

}

if err := epoller.Add(conn); err != nil {

log.Printf("failed to add connection %v", err)

conn.Close()

}

}

}

//返回接受的信息，小写转成大写字母

func replyConn(c net.Conn) error {

data,err:= pools.Read(c)

if err!=nil{

return err

}

err= pools.Write(c,[]byte(strings.ToUpper(string(data))))

return err

}