Go语言的连接池管理的具体使用

import (
	"database/sql"
	_ "github.com/go-sql-driver/mysql"
)

func main() {
	// 创建连接池
	db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/dbname")
	if err != nil {
		panic(err)
	}
	defer db.Close()

	// 设置连接池参数
	db.SetMaxOpenConns(25)  // 最大打开连接数
	db.SetMaxIdleConns(5)   // 最大空闲连接数
	db.SetConnMaxLifetime(time.Hour)  // 连接最大生命周期

	// 使用连接池执行查询
	rows, err := db.Query("SELECT * FROM users")
	if err != nil {
		panic(err)
	}
	defer rows.Close()

	// 处理查询结果
	for rows.Next() {
		var id int
		var name string
		if err := rows.Scan(&id, &name); err != nil {
			panic(err)
		}
		fmt.Printf("ID: %d, Name: %s\n", id, name)
	}
}

package pool

import (
	"sync"
	"time"
)

// Connection 接口定义了连接的基本操作
type Connection interface {
	Close() error
	Ping() error
}

// Pool 连接池结构体
type Pool struct {
	connections chan Connection
	factory     func() (Connection, error)
	mu          sync.Mutex
	closed      bool
}

// NewPool 创建一个新的连接池
func NewPool(factory func() (Connection, error), size int) *Pool {
	p := &Pool{
		connections: make(chan Connection, size),
		factory:     factory,
		closed:      false,
	}

	// 初始化连接池
	for i := 0; i < size; i++ {
		conn, err := factory()
		if err == nil {
			p.connections <- conn
		}
	}

	return p
}

// Get 从连接池中获取一个连接
func (p *Pool) Get() (Connection, error) {
	p.mu.Lock()
	if p.closed {
		p.mu.Unlock()
		return nil, errors.New("pool is closed")
	}
	p.mu.Unlock()

	select {
	case conn := <-p.connections:
		// 检查连接是否有效
		if err := conn.Ping(); err != nil {
			// 连接无效，创建新连接
			newConn, err := p.factory()
			if err != nil {
				return nil, err
			}
			return newConn, nil
		}
		return conn, nil
	default:
		// 连接池为空，创建新连接
		return p.factory()
	}
}

// Put 将连接放回连接池
func (p *Pool) Put(conn Connection) error {
	p.mu.Lock()
	defer p.mu.Unlock()

	if p.closed {
		return conn.Close()
	}

	select {
	case p.connections <- conn:
		return nil
	default:
		// 连接池已满，关闭多余的连接
		return conn.Close()
	}
}

// Close 关闭连接池
func (p *Pool) Close() error {
	p.mu.Lock()
	defer p.mu.Unlock()

	if p.closed {
		return nil
	}

	p.closed = true
	close(p.connections)

	for conn := range p.connections {
		conn.Close()
	}

	return nil
}