package workerpool

import (
    "context"
    "sync"
    "time"
)

// Task 任务接口
type Task interface {
    Execute(ctx context.Context) error
}

// WorkerPool 工作池
type WorkerPool struct {
    workers    int
    taskQueue  chan Task
    results    chan error
    wg         sync.WaitGroup
    ctx        context.Context
    cancel     context.CancelFunc
}

// NewWorkerPool 创建工作池
func NewWorkerPool(workers, queueSize int) *WorkerPool {
    ctx, cancel := context.WithCancel(context.Background())
    
    pool := &WorkerPool{
        workers:   workers,
        taskQueue: make(chan Task, queueSize),
        results:   make(chan error, queueSize),
        ctx:       ctx,
        cancel:    cancel,
    }
    
    // 启动worker goroutines
    for i := 0; i < workers; i++ {
        pool.wg.Add(1)
        go pool.worker(i)
    }
    
    return pool
}

// worker 工作goroutine
func (p *WorkerPool) worker(id int) {
    defer p.wg.Done()
    
    for {
        select {
        case task, ok := <-p.taskQueue:
            if !ok {
                return  // 任务队列关闭
            }
            
            // 执行任务
            err := task.Execute(p.ctx)
            
            // 发送结果
            select {
            case p.results <- err:
            case <-p.ctx.Done():
                return
            }
            
        case <-p.ctx.Done():
            return  // 上下文取消
        }
    }
}

// Submit 提交任务
func (p *WorkerPool) Submit(task Task) error {
    select {
    case p.taskQueue <- task:
        return nil
    case <-p.ctx.Done():
        return p.ctx.Err()
    }
}

// Shutdown 优雅关闭
func (p *WorkerPool) Shutdown() {
    close(p.taskQueue)  // 关闭任务队列
    p.wg.Wait()          // 等待所有worker完成
    close(p.results)     // 关闭结果通道
}

// Stop 强制停止
func (p *WorkerPool) Stop() {
    p.cancel()           // 取消上下文
    p.Shutdown()
}

// Results 获取结果通道
func (p *WorkerPool) Results() <-chan error {
    return p.results
}

package main

import (
    "context"
    "fmt"
    "time"
)

// ImageTask 图片处理任务
type ImageTask struct {
    URL string
}

func (t *ImageTask) Execute(ctx context.Context) error {
    // 模拟下载图片
    select {
    case <-time.After(100 * time.Millisecond):
        fmt.Printf("Processed image: %s\n", t.URL)
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}

func main() {
    // 创建worker池：10个worker,队列大小100
    pool := workerpool.NewWorkerPool(10, 100)
    defer pool.Shutdown()
    
    // 提交1000个任务
    go func() {
        for i := 0; i < 1000; i++ {
            task := &ImageTask{
                URL: fmt.Sprintf("https://example.com/image%d.jpg", i),
            }
            if err := pool.Submit(task); err != nil {
                fmt.Printf("Submit failed: %v\n", err)
                return
            }
        }
    }()
    
    // 收集结果
    successCount := 0
    errorCount := 0
    for err := range pool.Results() {
        if err != nil {
            errorCount++
        } else {
            successCount++
        }
    }
    
    fmt.Printf("Success: %d, Errors: %d\n", successCount, errorCount)
}

// BenchmarkWorkerPool 性能测试
func BenchmarkWorkerPool(b *testing.B) {
    pool := NewWorkerPool(runtime.NumCPU(), 1000)
    defer pool.Shutdown()
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        task := &DummyTask{}
        pool.Submit(task)
    }
}

// 结果:
// BenchmarkWorkerPool-8    500000    2500 ns/op    256 B/op    2 allocs/op

package ratelimit

import (
    "context"
    "sync"
    "time"
)

// TokenBucket 令牌桶限流器
type TokenBucket struct {
    rate       float64       // 令牌产生速率(每秒)
    capacity   int           // 桶容量
    tokens     float64       // 当前令牌数
    lastUpdate time.Time     // 上次更新时间
    mu         sync.Mutex
}

// NewTokenBucket 创建令牌桶
func NewTokenBucket(rate float64, capacity int) *TokenBucket {
    return &TokenBucket{
        rate:       rate,
        capacity:   capacity,
        tokens:     float64(capacity),
        lastUpdate: time.Now(),
    }
}

// Allow 检查是否允许通过
func (tb *TokenBucket) Allow() bool {
    tb.mu.Lock()
    defer tb.mu.Unlock()
    
    // 更新令牌数
    now := time.Now()
    elapsed := now.Sub(tb.lastUpdate).Seconds()
    tb.tokens += elapsed * tb.rate
    
    if tb.tokens > float64(tb.capacity) {
        tb.tokens = float64(tb.capacity)
    }
    tb.lastUpdate = now
    
    // 消费一个令牌
    if tb.tokens >= 1.0 {
        tb.tokens -= 1.0
        return true
    }
    
    return false
}

// Wait 等待直到获得令牌
func (tb *TokenBucket) Wait(ctx context.Context) error {
    for {
        if tb.Allow() {
            return nil
        }
        
        // 计算等待时间
        tb.mu.Lock()
        waitTime := time.Duration((1.0 - tb.tokens) / tb.rate * float64(time.Second))
        tb.mu.Unlock()
        
        // 等待或超时
        select {
        case <-time.After(waitTime):
        case <-ctx.Done():
            return ctx.Err()
        }
    }
}

// Reserve 预留令牌
func (tb *TokenBucket) Reserve(n int) time.Duration {
    tb.mu.Lock()
    defer tb.mu.Unlock()
    
    // 更新令牌
    now := time.Now()
    elapsed := now.Sub(tb.lastUpdate).Seconds()
    tb.tokens += elapsed * tb.rate
    
    if tb.tokens > float64(tb.capacity) {
        tb.tokens = float64(tb.capacity)
    }
    tb.lastUpdate = now
    
    // 计算等待时间
    tokens := float64(n)
    if tb.tokens >= tokens {
        tb.tokens -= tokens
        return 0
    }
    
    waitTokens := tokens - tb.tokens
    tb.tokens = 0
    return time.Duration(waitTokens / tb.rate * float64(time.Second))
}

package middleware

import (
    "net/http"
    "sync"
)

// RateLimitMiddleware 限流中间件
type RateLimitMiddleware struct {
    limiters sync.Map  // IP -> TokenBucket
    rate     float64
    capacity int
}

func NewRateLimitMiddleware(rate float64, capacity int) *RateLimitMiddleware {
    return &RateLimitMiddleware{
        rate:     rate,
        capacity: capacity,
    }
}

func (m *RateLimitMiddleware) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 获取客户端IP
        ip := r.RemoteAddr
        
        // 获取或创建限流器
        limiter, _ := m.limiters.LoadOrStore(ip, NewTokenBucket(m.rate, m.capacity))
        tb := limiter.(*TokenBucket)
        
        // 检查限流
        if !tb.Allow() {
            http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

// 使用示例
func main() {
    // 每秒10个请求,桶容量20
    limiter := NewRateLimitMiddleware(10.0, 20)
    
    mux := http.NewServeMux()
    mux.HandleFunc("/api", handleAPI)
    
    // 应用限流中间件
    http.ListenAndServe(":8080", limiter.Middleware(mux))
}

package ratelimit

import (
    "sync/atomic"
    "time"
)

// LockFreeTokenBucket 无锁令牌桶
type LockFreeTokenBucket struct {
    rate       int64  // 纳秒/令牌
    capacity   int64
    tokens     int64  // 原子变量
    lastUpdate int64  // 纳秒时间戳
}

func NewLockFreeTokenBucket(rate float64, capacity int) *LockFreeTokenBucket {
    return &LockFreeTokenBucket{
        rate:       int64(1e9 / rate),
        capacity:   int64(capacity),
        tokens:     int64(capacity) << 32,  // 高32位存令牌数
        lastUpdate: time.Now().UnixNano(),
    }
}

func (tb *LockFreeTokenBucket) Allow() bool {
    for {
        old := atomic.LoadInt64(&tb.tokens)
        now := time.Now().UnixNano()
        last := atomic.LoadInt64(&tb.lastUpdate)
        
        // 计算新令牌数
        tokens := old >> 32
        elapsed := now - last
        newTokens := tokens + elapsed/tb.rate
        
        if newTokens > tb.capacity {
            newTokens = tb.capacity
        }
        
        // 尝试消费令牌
        if newTokens >= 1 {
            newValue := ((newTokens - 1) << 32) | (now & 0xFFFFFFFF)
            if atomic.CompareAndSwapInt64(&tb.tokens, old, newValue) {
                atomic.StoreInt64(&tb.lastUpdate, now)
                return true
            }
        } else {
            return false
        }
    }
}

package distlock

import (
    "context"
    "errors"
    "time"
    
    "github.com/redis/go-redis/v9"
)

var (
    ErrLockFailed = errors.New("failed to acquire lock")
    ErrNotOwner   = errors.New("not lock owner")
)

// RedisLock Redis分布式锁
type RedisLock struct {
    client *redis.Client
    key    string
    value  string
    ttl    time.Duration
}

// Lock 获取锁
func (l *RedisLock) Lock(ctx context.Context) error {
    // 使用SET NX EX实现原子操作
    ok, err := l.client.SetNX(ctx, l.key, l.value, l.ttl).Result()
    if err != nil {
        return err
    }
    
    if !ok {
        return ErrLockFailed
    }
    
    // 启动续期goroutine
    go l.renew(ctx)
    
    return nil
}

// Unlock 释放锁
func (l *RedisLock) Unlock(ctx context.Context) error {
    // Lua脚本保证原子性：只有owner能删除
    script := `
        if redis.call("get", KEYS[1]) == ARGV[1] then
            return redis.call("del", KEYS[1])
        else
            return 0
        end
    `
    
    result, err := l.client.Eval(ctx, script, []string{l.key}, l.value).Result()
    if err != nil {
        return err
    }
    
    if result.(int64) == 0 {
        return ErrNotOwner
    }
    
    return nil
}

// renew 自动续期
func (l *RedisLock) renew(ctx context.Context) {
    ticker := time.NewTicker(l.ttl / 3)
    defer ticker.Stop()
    
    for {
        select {
        case <-ticker.C:
            // 续期
            script := `
                if redis.call("get", KEYS[1]) == ARGV[1] then
                    return redis.call("expire", KEYS[1], ARGV[2])
                else
                    return 0
                end
            `
            l.client.Eval(ctx, script, []string{l.key}, l.value, int(l.ttl.Seconds()))
            
        case <-ctx.Done():
            return
        }
    }
}

// TryLock 尝试获取锁
func (l *RedisLock) TryLock(ctx context.Context, timeout time.Duration) error {
    ctx, cancel := context.WithTimeout(ctx, timeout)
    defer cancel()
    
    ticker := time.NewTicker(10 * time.Millisecond)
    defer ticker.Stop()
    
    for {
        err := l.Lock(ctx)
        if err == nil {
            return nil
        }
        
        if err != ErrLockFailed {
            return err
        }
        
        select {
        case <-ticker.C:
            // 继续重试
        case <-ctx.Done():
            return ctx.Err()
        }
    }
}

func processWithLock(ctx context.Context, resourceID string) error {
    // 创建锁
    lock := &RedisLock{
        client: redisClient,
        key:    "lock:" + resourceID,
        value:  generateUUID(),
        ttl:    30 * time.Second,
    }
    
    // 获取锁
    if err := lock.TryLock(ctx, 5*time.Second); err != nil {
        return fmt.Errorf("failed to acquire lock: %w", err)
    }
    defer lock.Unlock(ctx)
    
    // 执行业务逻辑
    return processResource(resourceID)
}

// RedLock 多实例Redis锁
type RedLock struct {
    clients []*redis.Client
    quorum  int
    key     string
    value   string
    ttl     time.Duration
}

func (rl *RedLock) Lock(ctx context.Context) error {
    start := time.Now()
    locked := 0
    
    // 尝试在多个实例上加锁
    for _, client := range rl.clients {
        ok, err := client.SetNX(ctx, rl.key, rl.value, rl.ttl).Result()
        if err == nil && ok {
            locked++
        }
    }
    
    // 检查是否达到quorum
    elapsed := time.Since(start)
    validity := rl.ttl - elapsed - time.Duration(len(rl.clients))*time.Millisecond
    
    if locked >= rl.quorum && validity > 0 {
        return nil
    }
    
    // 加锁失败,释放已获取的锁
    rl.unlock(ctx)
    return ErrLockFailed
}

func (rl *RedLock) unlock(ctx context.Context) {
    script := `
        if redis.call("get", KEYS[1]) == ARGV[1] then
            return redis.call("del", KEYS[1])
        else
            return 0
        end
    `
    
    for _, client := range rl.clients {
        client.Eval(ctx, script, []string{rl.key}, rl.value)
    }
}

package pool

import (
    "bytes"
    "sync"
)

var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

// GetBuffer 获取buffer
func GetBuffer() *bytes.Buffer {
    return bufferPool.Get().(*bytes.Buffer)
}

// PutBuffer 归还buffer
func PutBuffer(buf *bytes.Buffer) {
    buf.Reset()
    bufferPool.Put(buf)
}

// 使用示例
func processData(data []byte) string {
    buf := GetBuffer()
    defer PutBuffer(buf)
    
    buf.Write(data)
    // 处理...
    return buf.String()
}

package pool

import (
    "sync"
)

// BoundedPool 有界对象池
type BoundedPool struct {
    pool     sync.Pool
    sem      chan struct{}
    maxSize  int
    size     int
    sizeMu   sync.Mutex
}

func NewBoundedPool(maxSize int, factory func() interface{}) *BoundedPool {
    return &BoundedPool{
        pool: sync.Pool{
            New: factory,
        },
        sem:     make(chan struct{}, maxSize),
        maxSize: maxSize,
    }
}

func (p *BoundedPool) Get() interface{} {
    // 获取信号量
    p.sem <- struct{}{}
    
    // 从池中获取或创建
    obj := p.pool.Get()
    
    p.sizeMu.Lock()
    p.size++
    p.sizeMu.Unlock()
    
    return obj
}

func (p *BoundedPool) Put(obj interface{}) {
    p.pool.Put(obj)
    
    p.sizeMu.Lock()
    p.size--
    p.sizeMu.Unlock()
    
    // 释放信号量
    <-p.sem
}

func (p *BoundedPool) Size() int {
    p.sizeMu.Lock()
    defer p.sizeMu.Unlock()
    return p.size
}

// 无对象池
func BenchmarkWithoutPool(b *testing.B) {
    for i := 0; i < b.N; i++ {
        buf := new(bytes.Buffer)
        buf.WriteString("test")
        _ = buf.String()
    }
}

// 使用对象池
func BenchmarkWithPool(b *testing.B) {
    for i := 0; i < b.N; i++ {
        buf := GetBuffer()
        buf.WriteString("test")
        _ = buf.String()
        PutBuffer(buf)
    }
}

// 结果:
// BenchmarkWithoutPool-8     5000000    250 ns/op    64 B/op    2 allocs/op
// BenchmarkWithPool-8       10000000    120 ns/op     0 B/op    0 allocs/op

go build -gcflags="-m -m" main.go

package escape

// 1. 返回局部变量指针 - 逃逸
func newInt() *int {
    x := 42
    return &x  // x escapes to heap
}

// 优化:返回值类型
func newIntValue() int {
    return 42  // 不逃逸
}

// 2. interface{}导致逃逸
func printAny(v interface{}) {
    fmt.Println(v)  // v escapes to heap
}

// 优化:使用具体类型
func printInt(v int) {
    fmt.Println(v)  // 可能不逃逸
}

// 3. slice append可能导致逃逸
func appendSlice() []int {
    s := make([]int, 0, 10)
    s = append(s, 1)  // s escapes to heap
    return s
}

// 优化:预分配并传入
func appendSliceOptimized(s []int) []int {
    return append(s, 1)  // s可能不逃逸
}

// 4. 闭包捕获导致逃逸
func closure() func() int {
    x := 42
    return func() int {
        return x  // x escapes to heap
    }
}

// 优化:避免闭包或使用参数传递
func closureOptimized(x int) func() int {
    return func() int {
        return x  // 参数不逃逸
    }
}

// 不推荐:大数组在栈上
func processLargeArray() {
    var data [1000000]int  // 4MB,栈溢出风险
    // ...
}

// 推荐:使用slice或指针
func processLargeArrayOptimized() {
    data := make([]int, 1000000)  // 堆分配
    // ...
}

package gcmon

import (
    "runtime"
    "time"
)

// GCStats GC统计信息
type GCStats struct {
    NumGC        uint32
    PauseTotal   time.Duration
    PauseAvg     time.Duration
    LastPause    time.Duration
    HeapAlloc    uint64
    HeapSys      uint64
    HeapInuse    uint64
}

func GetGCStats() GCStats {
    var stats runtime.MemStats
    runtime.ReadMemStats(&stats)
    
    pauseAvg := time.Duration(0)
    if stats.NumGC > 0 {
        pauseAvg = time.Duration(stats.PauseTotalNs / uint64(stats.NumGC))
    }
    
    lastPause := time.Duration(0)
    if stats.NumGC > 0 {
        lastPause = time.Duration(stats.PauseNs[(stats.NumGC+255)%256])
    }
    
    return GCStats{
        NumGC:      stats.NumGC,
        PauseTotal: time.Duration(stats.PauseTotalNs),
        PauseAvg:   pauseAvg,
        LastPause:  lastPause,
        HeapAlloc:  stats.Alloc / 1024 / 1024,      // MB
        HeapSys:    stats.Sys / 1024 / 1024,        // MB
        HeapInuse:  stats.HeapInuse / 1024 / 1024,  // MB
    }
}

// 监控示例
func monitorGC(interval time.Duration) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()
    
    for range ticker.C {
        stats := GetGCStats()
        fmt.Printf("GC: NumGC=%d, PauseAvg=%v, HeapAlloc=%dMB\n",
            stats.NumGC, stats.PauseAvg, stats.HeapAlloc)
    }
}

# 1. GOGC - 控制GC触发频率
GOGC=100  # 默认:堆增长100%触发GC
GOGC=200  # 降低GC频率,增加内存使用
GOGC=50   # 增加GC频率,降低内存使用

# 2. GOMEMLIMIT - 软内存上限(Go 1.19+)
GOMEMLIMIT=4GiB  # 接近4GB时更频繁GC

# 3. GODEBUG - GC追踪
GODEBUG=gctrace=1  # 打印GC信息

// 1. 减少指针密集型结构
type BadStruct struct {
    A *int
    B *string
    C *float64
    // GC需要扫描所有指针
}

type GoodStruct struct {
    A int
    B string
    C float64
    // GC扫描更快
}

// 2. 批量分配减少GC
func batchAlloc() {
    // 不推荐:逐个分配
    for i := 0; i < 1000; i++ {
        data := make([]byte, 1024)
        process(data)
    }
    
    // 推荐:批量分配
    buffer := make([]byte, 1024*1000)
    for i := 0; i < 1000; i++ {
        data := buffer[i*1024 : (i+1)*1024]
        process(data)
    }
}

// 3. 明确触发GC(仅特殊场景)
func explicitGC() {
    // 完成大量操作后
    performHeavyWork()
    
    // 手动触发GC
    runtime.GC()
    
    // 进入空闲期
    idle()
}

package httpserver

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

// Server HTTP服务器
type Server struct {
    server *http.Server
}

func NewServer(addr string, handler http.Handler) *Server {
    return &Server{
        server: &http.Server{
            Addr:         addr,
            Handler:      handler,
            ReadTimeout:  15 * time.Second,
            WriteTimeout: 15 * time.Second,
            IdleTimeout:  60 * time.Second,
        },
    }
}

// Start 启动服务器
func (s *Server) Start() error {
    log.Printf("Server listening on %s\n", s.server.Addr)
    
    if err := s.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        return err
    }
    
    return nil
}

// Shutdown 优雅关闭
func (s *Server) Shutdown(timeout time.Duration) error {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()
    
    log.Println("Shutting down server...")
    
    if err := s.server.Shutdown(ctx); err != nil {
        return err
    }
    
    log.Println("Server stopped")
    return nil
}

// 使用示例
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", handleRoot)
    mux.HandleFunc("/api/data", handleData)
    
    server := NewServer(":8080", mux)
    
    // 启动服务器
    go func() {
        if err := server.Start(); err != nil {
            log.Fatal(err)
        }
    }()
    
    // 等待退出信号
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan
    
    // 优雅关闭
    if err := server.Shutdown(30 * time.Second); err != nil {
        log.Fatal(err)
    }
}