性能优化

import "runtime/pprof"

func main() {
    f, err := os.Create("cpu.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    if err := pprof.StartCPUProfile(f); err != nil {
        log.Fatal(err)
    }
    defer pprof.StopCPUProfile()
    
    // 你的应用代码
}

import "runtime/pprof"

func main() {
    f, err := os.Create("mem.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    // 你的应用代码
    
    if err := pprof.WriteHeapProfile(f); err != nil {
        log.Fatal(err)
    }
}

// 不好的做法：频繁分配
func process(data []byte) string {
    return string(data) // 每次分配新字符串
}

// 优化做法：复用缓冲区
var bufPool = sync.Pool{
    New: func() interface{} {
        return bytes.NewBuffer(make([]byte, 0, 1024))
    },
}

func processOptimized(data []byte) string {
    buf := bufPool.Get().(*bytes.Buffer)
    defer bufPool.Put(buf)
    buf.Reset()
    buf.Write(data)
    return buf.String()
}

// 指针类型(可能增加GC压力)
type User struct {
    Name *string
    Age  *int
}

// 值类型(更高效)
type User struct {
    Name string
    Age  int
}

func workerPool(jobs <-chan Job, results chan<- Result) {
    var wg sync.WaitGroup
    for i := 0; i < runtime.NumCPU(); i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

func batchProcess(items []Item) {
    batchSize := 100
    var wg sync.WaitGroup
    
    for i := 0; i < len(items); i += batchSize {
        wg.Add(1)
        go func(start int) {
            defer wg.Done()
            end := start + batchSize
            if end > len(items) {
                end = len(items)
            }
            processBatch(items[start:end])
        }(i)
    }
    
    wg.Wait()
}

func createHTTPClient() *http.Client {
    return &http.Client{
        Transport: &http.Transport{
            MaxIdleConns:        100,
            MaxIdleConnsPerHost: 100,
            IdleConnTimeout:     90 * time.Second,
            TLSHandshakeTimeout: 10 * time.Second,
            DialContext: (&net.Dialer{
                Timeout:   30 * time.Second,
                KeepAlive: 30 * time.Second,
            }).DialContext,
        },
        Timeout: 60 * time.Second,
    }
}

func main() {
    // 生产模式(禁用调试和彩色日志)
    gin.SetMode(gin.ReleaseMode)
    
    r := gin.New()
    
    // 使用中间件
    r.Use(gin.Recovery())
    
    // 禁用控制台颜色
    gin.DisableConsoleColor()
    
    // 路由分组
    api := r.Group("/api")
    {
        api.GET("/users", getUsers)
        api.GET("/orders", getOrders)
    }
    
    // 静态文件服务(带缓存控制)
    r.Static("/static", "./public")
    
    // 启动服务
    s := &http.Server{
        Addr:         ":8080",
        Handler:      r,
        ReadTimeout:  30 * time.Second,
        WriteTimeout: 30 * time.Second,
        IdleTimeout:  120 * time.Second,
    }
    s.ListenAndServe()
}

// 不好的做法：单条插入
for _, user := range users {
    _, err := db.Exec("INSERT INTO users (name, email) VALUES (?, ?)", 
        user.Name, user.Email)
    if err != nil {
        return err
    }
}

// 优化做法：批量插入
valueStrings := make([]string, 0, len(users))
valueArgs := make([]interface{}, 0, len(users)*2)
for _, user := range users {
    valueStrings = append(valueStrings, "(?, ?)")
    valueArgs = append(valueArgs, user.Name)
    valueArgs = append(valueArgs, user.Email)
}
stmt := fmt.Sprintf("INSERT INTO users (name, email) VALUES %s",
    strings.Join(valueStrings, ","))
_, err := db.Exec(stmt, valueArgs...)

// 创建预处理语句
stmt, err := db.Prepare("SELECT id, name FROM users WHERE email = ?")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

// 复用预处理语句
for _, email := range emails {
    var user User
    err := stmt.QueryRow(email).Scan(&user.ID, &user.Name)
    if err != nil {
        log.Println(err)
        continue
    }
    // 处理用户...
}