Golang 包级变量的并发安全性与最佳实践

package main

import "fmt"

var globalCounter int = 0 // 包级变量

func increment() {
    globalCounter++
}

func main() {
    increment()
    fmt.Println(globalCounter) // 输出 1
}

package main

import (
    "fmt"
    "net/http"
    "time"
)

// CurrentUser 是一个包级变量，用于存储当前用户
// 这是一个不安全的实践，会导致竞态条件
var CurrentUser *string

func handlerProblematic(w http.ResponseWriter, r *http.Request) {
    user := r.URL.Query().Get("user")
    if user == "" {
        user = "Guest"
    }

    // 模拟设置CurrentUser
    CurrentUser = &user
    fmt.Printf("Request from %s: CurrentUser set to %s\n", user, *CurrentUser)

    // 模拟一些耗时操作，期间其他请求可能修改 CurrentUser
    time.Sleep(100 * time.Millisecond)

    // 在此期间，CurrentUser可能已经被其他请求修改
    fmt.Fprintf(w, "Hello, %s! Your CurrentUser (potentially outdated) is %s\n", user, *CurrentUser)
}

func main() {
    http.HandleFunc("/problem", handlerProblematic)
    fmt.Println("Server started on :8080. Visit /problem?user=John and /problem?user=Fred concurrently.")
    // 运行此服务，并尝试快速访问 /problem?user=John 和 /problem?user=Fred
    // 你会发现 John 的请求可能最终显示 Fred 的 CurrentUser
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "fmt"
    "net/http"
    "time"
)

// 在这个示例中，我们不再使用包级变量来存储用户会话信息。

func handlerCorrect(w http.ResponseWriter, r *http.Request) {
    // 将用户数据作为局部变量处理
    user := r.URL.Query().Get("user")
    if user == "" {
        user = "Guest"
    }

    // 此时，user变量是当前goroutine私有的，不会被其他goroutine影响
    fmt.Printf("Request from %s: Processing user %s\n", user, user)

    // 模拟一些耗时操作
    time.Sleep(100 * time.Millisecond)

    // 确保响应使用的是当前请求的user变量
    fmt.Fprintf(w, "Hello, %s! Your request was processed for user %s\n", user, user)
}

// func main() { // main函数已在上方示例中定义，此处省略以避免重复
//  http.HandleFunc("/correct", handlerCorrect)
//  fmt.Println("Server started on :8080. Visit /correct?user=John and /correct?user=Fred concurrently.")
//  http.ListenAndServe(":8080", nil)
// }

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    sharedCounter int
    mu            sync.Mutex // 保护 sharedCounter 的互斥锁
)

func incrementCounter() {
    mu.Lock()         // 加锁
    sharedCounter++   // 访问共享资源
    mu.Unlock()       // 解锁
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            incrementCounter()
        }()
    }

    wg.Wait() // 等待所有goroutine完成
    fmt.Println("Final Counter:", sharedCounter) // 预期输出 1000
}