package main

import (
	"encoding/json"
	"fmt"
	"sync"
	"time"
)

// 要序列化的数据结构
type User struct {
	Name string
	Age  int
	Emails []string
}

// 不使用Pool，每次调用都创建新的Encoder和Buffer
func serializeWithoutPool(user *User) ([]byte, error) {
	// 每次调用都会创建新的buffer和encoder
	var buf []byte // 这里使用byte slice作为模拟的buffer
	var err error
	// 模拟一次较耗时的序列化
	for i := 0; i < 100; i++ {
		buf, err = json.Marshal(user)
		if err != nil {
			return nil, err
		}
	}
	_ = buf // 仅用于演示
	return nil, nil
}

// 使用Pool来复用Encoder（这里用json.Encoder的池作为例子，原理相通）
var encoderPool = sync.Pool{
	// New函数在池中无可用对象时被调用，创建一个新的对象
	New: func() interface{} {
		// 创建一个用于序列化的缓冲区
		return make([]byte, 0, 1024) // 预分配一个初始容量
	},
}

func serializeWithPool(user *User) ([]byte, error) {
	// 从池中获取一个缓冲区
	buf := encoderPool.Get().([]byte)
	// 确保用完后归还，且重置长度（重要！）
	defer func() {
		buf = buf[:0] // 重置长度，但保留底层数组容量
		encoderPool.Put(buf)
	}()

	// 模拟使用缓冲区进行序列化工作
	for i := 0; i < 100; i++ {
		var err error
		buf, err = json.Marshal(user) // 实际使用时可能直接写入buf
		if err != nil {
			return nil, err
		}
	}
	// 返回buf的副本，因为buf将被归还池
	result := make([]byte, len(buf))
	copy(result, buf)
	return result, nil
}

func main() {
	user := &User{Name: "Alice", Age: 30, Emails: []string{"[email protected]", "[email protected]"}}
	
	start := time.Now()
	// 模拟高并发调用
	for i := 0; i < 100000; i++ {
		serializeWithoutPool(user)
	}
	fmt.Printf("Without Pool: %v\n", time.Since(start))

	start = time.Now()
	for i := 0; i < 100000; i++ {
		serializeWithPool(user)
	}
	fmt.Printf("With Pool:    %v\n", time.Since(start))
}
// 运行建议：go run -race main.go 查看竞态，go test -bench=. 测试性能

package main

import "fmt"

// 动态追加：可能多次扩容
func appendDynamically(n int) []int {
	var s []int
	for i := 0; i < n; i++ {
		s = append(s, i) // 每次append都可能检查容量并扩容
	}
	return s
}

// 预分配：只分配一次
func appendWithPrealloc(n int) []int {
	s := make([]int, 0, n) // 预分配n个元素的容量
	for i := 0; i < n; i++ {
		s = append(s, i) // 这里append只增加长度，不触发扩容
	}
	return s
}

// 复用切片：常见于解析器、批量处理
func processBatches(items []string) {
	// 复用一个切片来存储批次结果
	batch := make([]string, 0, 100) // 预分配，假设每批100个
	for i, item := range items {
		batch = append(batch, item)
		if len(batch) == cap(batch) {
			// 处理当前批次
			fmt.Printf("Processing batch: %v\n", batch)
			// 复用切片：重置长度，但保留底层数组
			batch = batch[:0]
		}
	}
	// 处理最后不足一批的数据
	if len(batch) > 0 {
		fmt.Printf("Processing final batch: %v\n", batch)
	}
}

func main() {
	// 对比两种追加方式
	s1 := appendDynamically(1000)
	s2 := appendWithPrealloc(1000)
	fmt.Printf("动态追加 len:%d, cap:%d\n", len(s1), cap(s1)) // 容量可能不是1000
	fmt.Printf("预分配   len:%d, cap:%d\n", len(s2), cap(s2)) // 容量正好是1000

	// 演示切片复用
	items := make([]string, 250)
	for i := range items {
		items[i] = fmt.Sprintf("item%d", i)
	}
	processBatches(items)
}