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
    SetPointer(&data1)

    fmt.Printf("初始值: %d\n", *CurrentPointer()) // 输出: 初始值: 100

    // 模拟并发读写
    go func() {
        data2 := 200
        SetPointer(&data2) // Goroutine 1 写入新指针
        fmt.Printf("Goroutine 1 写入后: %d\n", *CurrentPointer())
    }()

    go func() {
        time.Sleep(50 * time.Millisecond) // 稍作延迟，模拟并发
        fmt.Printf("Goroutine 2 读取: %d\n", *CurrentPointer()) // Goroutine 2 读取
    }()

    time.Sleep(100 * time.Millisecond) // 等待所有Goroutine完成
    fmt.Printf("主Goroutine 最终读取: %d\n", *CurrentPointer())
}

package main

import (
    "fmt"
    "sync/atomic"
    "unsafe"
    "time"
)

type MyStruct struct {
    value int
}

// 使用unsafe.Pointer存储实际的数据指针
type AtomicPointerContainer struct {
    ptr unsafe.Pointer // 存储 *MyStruct 类型的 unsafe.Pointer
}

func main() {
    data1 := &MyStruct{value: 100}
    container := AtomicPointerContainer{ptr: unsafe.Pointer(data1)}

    // 原子加载指针并解引用
    loadedPtr := (*MyStruct)(atomic.LoadPointer(&container.ptr))
    fmt.Printf("初始值: %d\n", loadedPtr.value) // 输出: 初始值: 100

    // 模拟并发更新
    go func() {
        data2 := &MyStruct{value: 200}
        // 原子存储新指针
        atomic.StorePointer(&container.ptr, unsafe.Pointer(data2))
        fmt.Printf("Goroutine 1 写入后: %d\n", (*MyStruct)(atomic.LoadPointer(&container.ptr)).value)
    }()

    go func() {
        time.Sleep(50 * time.Millisecond) // 稍作延迟
        // 原子加载指针并解引用
        current := (*MyStruct)(atomic.LoadPointer(&container.ptr))
        fmt.Printf("Goroutine 2 读取: %d\n", current.value)
    }()

    time.Sleep(100 * time.Millisecond) // 等待所有Goroutine完成
    final := (*MyStruct)(atomic.LoadPointer(&container.ptr))
    fmt.Printf("主Goroutine 最终读取: %d\n", final.value)
}

package main

import (
    "fmt"
    "time"
)

type PointerCommand int

const (
    Get PointerCommand = iota
    Set
)

type PointerRequest struct {
    Command PointerCommand
    Value   *int        // Set命令时携带的值
    Resp    chan *int   // Get命令时返回值的通道
}

// pointerManager 协程管理共享指针
func pointerManager(requests <-chan PointerRequest) {
    var currentPointer *int
    for req := range requests {
        switch req.Command {
        case Get:
            if req.Resp != nil {
                req.Resp <- currentPointer
            }
        case Set:
            currentPointer = req.Value
        }
    }
}

func main() {
    requests := make(chan PointerRequest)
    go pointerManager(requests) // 启动指针管理器协程

    // 设置初始值
    val1 := 100
    requests <- PointerRequest{Command: Set, Value: &val1}

    // 获取值
    respChan := make(chan *int)
    requests <- PointerRequest{Command: Get, Resp: respChan}
    ptr := <-respChan
    fmt.Printf("初始值: %d\n", *ptr)

    // 模拟并发更新
    go func() {
        val2 := 200
        requests <- PointerRequest{Command: Set, Value: &val2}
        time.Sleep(50 * time.Millisecond) // 模拟其他操作
        requests <- PointerRequest{Command: Get, Resp: respChan}
        ptr := <-respChan
        fmt.Printf("Goroutine 1 读取: %d\n", *ptr)
    }()

    go func() {
        time.Sleep(20 * time.Millisecond) // 稍作延迟
        requests <- PointerRequest{Command: Get, Resp: respChan}
        ptr := <-respChan
        fmt.Printf("Goroutine 2 读取: %d\n", *ptr)
    }()

    time.Sleep(150 * time.Millisecond) // 等待所有Goroutine完成
    requests <- PointerRequest{Command: Get, Resp: respChan}
    finalPtr := <-respChan
    fmt.Printf("主Goroutine 最终读取: %d\n", *finalPtr)

    close(requests) // 关闭请求通道，通知管理器协程退出
}