Go语言中Pool对象复用的实现

package main
import (
	"fmt"
	"sync"
)
// 创建一个Pool
var pool = sync.Pool{
	New: func() interface{} {
		fmt.Println("Creating new object")
		return make([]byte, 1024)
	},
}
func main() {
	// 从Pool获取对象
	obj := pool.Get().([]byte)
	fmt.Printf("Got object with length: %d\n", len(obj))
	// 使用对象
	copy(obj, "Hello, World!")
	fmt.Println(string(obj))
	// 将对象放回Pool
	pool.Put(obj)
	// 再次从Pool获取对象
	obj2 := pool.Get().([]byte)
	fmt.Printf("Got object with length: %d\n", len(obj2))
	fmt.Println(string(obj2))
	// 放回Pool
	pool.Put(obj2)
}

package main
import (
	"fmt"
	"sync"
)
type Buffer struct {
	Data []byte
	Size int
}
var bufferPool = sync.Pool{
	New: func() interface{} {
		fmt.Println("Creating new buffer")
		return &Buffer{
			Data: make([]byte, 0, 1024),
			Size: 0,
		}
	},
}
func getBuffer() *Buffer {
	buf := bufferPool.Get().(*Buffer)
	buf.Data = buf.Data[:0] // 重置但不释放底层数组
	buf.Size = 0
	return buf
}
func putBuffer(buf *Buffer) {
	bufferPool.Put(buf)
}
func main() {
	// 获取缓冲区
	buf := getBuffer()
	buf.Data = append(buf.Data, "Hello, World!"...)
	buf.Size = len(buf.Data)
	fmt.Printf("Buffer: %s, Size: %d\n", string(buf.Data), buf.Size)
	// 放回Pool
	putBuffer(buf)
	// 再次获取
	buf2 := getBuffer()
	fmt.Printf("Buffer capacity: %d\n", cap(buf2.Data))
	putBuffer(buf2)
}

package main
import (
	"fmt"
	"sync"
	"time"
)
// 使用Pool
var bytePool = sync.Pool{
	New: func() interface{} {
		return make([]byte, 1024)
	},
}
func withPool() {
	for i := 0; i < 1000000; i++ {
		buf := bytePool.Get().([]byte)
		// 使用buf
		_ = buf
		bytePool.Put(buf)
	}
}
func withoutPool() {
	for i := 0; i < 1000000; i++ {
		buf := make([]byte, 1024)
		// 使用buf
		_ = buf
	}
}
func main() {
	// 测试使用Pool的性能
	start := time.Now()
	withPool()
	duration1 := time.Since(start)
	// 测试不使用Pool的性能
	start = time.Now()
	withoutPool()
	duration2 := time.Since(start)
	fmt.Printf("With Pool: %v\n", duration1)
	fmt.Printf("Without Pool: %v\n", duration2)
}

package main
import (
	"fmt"
	"net/http"
	"sync"
)
var requestPool = sync.Pool{
	New: func() interface{} {
		return &http.Request{}
	},
}
func handleRequest(w http.ResponseWriter, r *http.Request) {
	// 从Pool获取请求对象
	req := requestPool.Get().(*http.Request)
	defer requestPool.Put(req)
	// 重置请求对象
	*req = *r
	// 处理请求
	fmt.Fprintf(w, "Request processed: %s\n", req.URL.Path)
}
func main() {
	http.HandleFunc("/", handleRequest)
	http.ListenAndServe(":8080", nil)
}

package main

import (
	"database/sql"
	"fmt"
	"sync"
)

type DBConnection struct {
	Conn *sql.DB
	ID   int
}

var connPool = sync.Pool{
	New: func() interface{} {
		// 创建新的数据库连接
		return &DBConnection{
			Conn: nil,
			ID:   0,
		}
	},
}

func getConnection() *DBConnection {
	conn := connPool.Get().(*DBConnection)
	if conn.Conn == nil {
		// 初始化连接
		fmt.Println("Initializing new connection")
	}
	return conn
}

func putConnection(conn *DBConnection) {
	// 重置连接状态
	conn.ID = 0
	connPool.Put(conn)
}

func main() {
	// 获取连接
	conn := getConnection()
	fmt.Printf("Connection ID: %d\n", conn.ID)
	
	// 使用连接
	conn.ID = 1
	
	// 放回Pool
	putConnection(conn)
	
	// 再次获取
	conn2 := getConnection()
	fmt.Printf("Connection ID: %d\n", conn2.ID)
	putConnection(conn2)
}

package main
import (
	"bytes"
	"fmt"
	"sync"
)
var bufferPool = sync.Pool{
	New: func() interface{} {
		return new(bytes.Buffer)
	},
}
func processData(data []byte) string {
	// 从Pool获取缓冲区
	buf := bufferPool.Get().(*bytes.Buffer)
	defer bufferPool.Put(buf)
	// 重置缓冲区
	buf.Reset()
	// 处理数据
	buf.Write(data)
	buf.WriteString(" - processed")
	return buf.String()
}
func main() {
	// 处理多个数据
	datas := [][]byte{
		[]byte("Hello"),
		[]byte("World"),
		[]byte("Go"),
		[]byte("Language"),
	}
	for _, data := range datas {
		result := processData(data)
		fmt.Println(result)
	}
}