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())

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

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

    time.Sleep(100 * time.Millisecond) // 等待协程执行完毕
    fmt.Printf("最终值: %d\n", *CurrentPointer())
}

package main

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

type MyStruct struct {
    p unsafe.Pointer // 存储任意类型指针的原子字段
}

func main() {
    data1 := 100
    info := MyStruct{p: unsafe.Pointer(&data1)}

    fmt.Printf("初始值: %d\n", *(*int)(info.p))

    data2 := 200
    // 原子地将info.p指向data2的地址
    atomic.StorePointer(&info.p, unsafe.Pointer(&data2))

    fmt.Printf("更新后: %d\n", *(*int)(info.p))

    data3 := 300
    // 原子地加载指针值
    loadedPtr := atomic.LoadPointer(&info.p)
    fmt.Printf("原子加载值: %d\n", *(*int)(loadedPtr))
}

package main

import (
    "fmt"
    "time"
)

// PointerCommand 定义对指针的操作类型
type PointerCommand int

const (
    Set PointerCommand = iota
    Get
)

// PointerRequest 定义请求结构
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 Set:
            currentPointer = req.Value
        case Get:
            if req.Resp != nil {
                req.Resp <- currentPointer
            }
        }
    }
}

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

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

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

    // 模拟并发更新
    go func() {
        data2 := 200
        requests <- PointerRequest{Command: Set, Value: &data2}
        time.Sleep(10 * time.Millisecond) // 确保更新完成
        requests <- PointerRequest{Command: Get, Resp: respChan}
        ptr := <-respChan
        fmt.Printf("协程1更新后: %d\n", *ptr)
    }()

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

    time.Sleep(100 * time.Millisecond) // 等待协程执行完毕
    requests <- PointerRequest{Command: Get, Resp: respChan}
    finalPtr := <-respChan
    fmt.Printf("最终值: %d\n", *finalPtr)

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