Go语言中指针赋值的原子性与并发安全实践

package main

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

var secretPointer *int
var pointerLock sync.Mutex

// CurrentPointer 安全地获取当前指针的值
func CurrentPointer() *int {
    pointerLock.Lock()
    defer pointerLock.Unlock() // 确保锁在函数返回时释放
    return secretPointer
}

// SetPointer 安全地设置指针的值
func SetPointer(p *int) {
    pointerLock.Lock()
    secretPointer = p
    pointerLock.Unlock() // 释放锁
}

func main() {
    data1 := 100
    data2 := 200
    data3 := 300

    // 初始设置指针
    SetPointer(&data1)
    fmt.Printf("初始值: %d\n", *CurrentPointer()) // 100

    // 模拟并发读写
    go func() {
        for i := 0; i < 5; i++ {
            SetPointer(&data2) // goroutine 1 写入
            time.Sleep(10 * time.Millisecond)
        }
    }()

    go func() {
        for i := 0; i < 5; i++ {
            p := CurrentPointer() // goroutine 2 读取
            if p != nil {
                fmt.Printf("读取值: %d\n", *p)
            }
            time.Sleep(15 * time.Millisecond)
        }
    }()

    time.Sleep(200 * time.Millisecond) // 等待goroutine完成
    SetPointer(&data3)
    fmt.Printf("最终值: %d\n", *CurrentPointer()) // 300
}

package main

import (
    "fmt"
    "sync/atomic"
    "unsafe" // 导入 unsafe 包

    "time"
)

type Config struct {
    Name    string
    Version int
}

// currentConfigPtr 用于存储当前配置的原子指针
var currentConfigPtr unsafe.Pointer

func main() {
    // 初始配置
    cfg1 := Config{Name: "v1", Version: 1}
    atomic.StorePointer(&currentConfigPtr, unsafe.Pointer(&cfg1))

    fmt.Printf("初始配置: %+v\n", *(*Config)(atomic.LoadPointer(&currentConfigPtr)))

    // 模拟并发更新和读取
    go func() {
        for i := 0; i < 5; i++ {
            newCfg := Config{Name: fmt.Sprintf("v%d", i+2), Version: i + 2}
            atomic.StorePointer(&currentConfigPtr, unsafe.Pointer(&newCfg)) // 原子更新
            time.Sleep(10 * time.Millisecond)
        }
    }()

    go func() {
        for i := 0; i < 5; i++ {
            ptr := atomic.LoadPointer(&currentConfigPtr) // 原子读取
            if ptr != nil {
                cfg := (*Config)(ptr) // 类型转换
                fmt.Printf("读取配置: %+v\n", *cfg)
            }
            time.Sleep(15 * time.Millisecond)
        }
    }()

    time.Sleep(200 * time.Millisecond) // 等待goroutine完成

    finalPtr := atomic.LoadPointer(&currentConfigPtr)
    fmt.Printf("最终配置: %+v\n", *(*Config)(finalPtr))
}

package main

import (
    "fmt"
    "time"
)

type Command int

const (
    Get Command = iota
    Set
)

type PointerOp struct {
    Cmd    Command
    Value  *int      // Set操作时携带的值
    Result chan *int // Get操作时返回结果的通道
}

// PointerManager 负责管理指针的goroutine
func PointerManager(ops <-chan PointerOp) {
    var currentPointer *int // 只有这个goroutine能直接访问
    for op := range ops {
        switch op.Cmd {
        case Get:
            op.Result <- currentPointer
        case Set:
            currentPointer = op.Value
        }
    }
}

func main() {
    ops := make(chan PointerOp)
    go PointerManager(ops) // 启动指针管理器goroutine

    data1 := 100
    data2 := 200

    // 设置指针
    ops <- PointerOp{Cmd: Set, Value: &data1}

    // 获取指针
    resultChan := make(chan *int)
    ops <- PointerOp{Cmd: Get, Result: resultChan}
    ptr := <-resultChan
    if ptr != nil {
        fmt.Printf("获取到的值: %d\n", *ptr) // 100
    }

    // 再次设置
    ops <- PointerOp{Cmd: Set, Value: &data2}

    // 再次获取
    ops <- PointerOp{Cmd: Get, Result: resultChan}
    ptr = <-resultChan
    if ptr != nil {
        fmt.Printf("再次获取到的值: %d\n", *ptr) // 200
    }

    close(ops) // 关闭通道，停止管理器goroutine
    time.Sleep(10 * time.Millisecond) // 等待goroutine退出
}