深入理解Go语言包级变量的线程安全性

package main

import "fmt"

var PackageLevelVariable int = 10 // 这是一个包级变量

func main() {
    fmt.Println(PackageLevelVariable)
    AnotherFunction()
}

func AnotherFunction() {
    PackageLevelVariable = 20 // 可以在不同函数中修改
    fmt.Println(PackageLevelVariable)
}

package main

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

var currentUser *string // 不安全的包级变量，用于存储当前用户

func handler(w http.ResponseWriter, r *http.Request) {
    user := r.URL.Query().Get("user")
    fmt.Printf("请求开始，用户: %s\n", user)

    // 模拟一些处理时间
    time.Sleep(100 * time.Millisecond)

    // 不安全的操作：将用户设置到包级变量
    // 在此期间，另一个goroutine可能已经修改了currentUser
    currentUser = &user

    // 模拟后续操作，可能依赖currentUser
    time.Sleep(100 * time.Millisecond)

    // 在此点，currentUser可能已经被其他请求修改，
    // 导致当前请求获取到错误的用户信息
    fmt.Fprintf(w, "Hello, %s! (Original request by: %s)\n", *currentUser, user)
    fmt.Printf("请求结束，用户: %s，实际输出: %s\n", user, *currentUser)
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Server started on :8080. Try accessing with /?user=John and /?user=Fred concurrently.")
    http.ListenAndServe(":8080", nil)
}

请求开始，用户: John
请求开始，用户: Fred
请求结束，用户: Fred，实际输出: Fred
Hello, Fred! (Original request by: John)
请求结束，用户: John，实际输出: Fred

func safeHandlerLocal(w http.ResponseWriter, r *http.Request) {
    user := r.URL.Query().Get("user") // user 是局部变量
    time.Sleep(100 * time.Millisecond)
    fmt.Fprintf(w, "Hello, %s!\n", user) // 总是输出正确的用户
}

func processUser(user string) {
    // 使用传入的 user 参数，而不是包级变量
    fmt.Printf("Processing user: %s\n", user)
}

func anotherSafeHandler(w http.ResponseWriter, r *http.Request) {
    user := r.URL.Query().Get("user")
    processUser(user) // 将 user 作为参数传递
    fmt.Fprintf(w, "Hello, %s!\n", user)
}

package main

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

// 定义一个context key，建议使用自定义类型以避免冲突
type userKeyType string
const userKey userKeyType = "user"

func safeHandlerWithContext(w http.ResponseWriter, r *http.Request) {
    // 获取用户参数
    user := r.URL.Query().Get("user")
    fmt.Printf("请求开始，用户: %s\n", user)

    // 将用户数据存储在请求的context中
    // context.WithValue 返回一个新的context，包含指定的值
    ctx := context.WithValue(r.Context(), userKey, user)
    // 使用新的context更新请求对象，以便后续处理函数可以访问
    r = r.WithContext(ctx)

    // 模拟处理时间
    time.Sleep(100 * time.Millisecond)

    // 从context中获取用户数据（安全的，请求级别）
    currentUserFromCtx, ok := r.Context().Value(userKey).(string)
    if !ok {
        currentUserFromCtx = "Guest"
    }

    // 模拟后续操作
    time.Sleep(100 * time.Millisecond)

    fmt.Fprintf(w, "Hello, %s! (Original request by: %s)\n", currentUserFromCtx, user)
    fmt.Printf("请求结束，用户: %s，实际输出: %s\n", user, currentUserFromCtx)
}

func main() {
    http.HandleFunc("/", safeHandlerWithContext)
    fmt.Println("Server started on :8080. Try accessing with /?user=John and /?user=Fred concurrently.")
    http.ListenAndServe(":8080", nil)
}