Value

  1. // Value 针对一个指定的类型提供 load 和 store 两个原子操作
  2. type Value struct {
  3.     v interface{}
  4. }
  6. // Load returns the value set by the most recent Store.
  7. // It returns nil if there has been no call to Store for this Value.
  8. func (v *Value) Load() (x interface{}) {
  9.     vp := (*ifaceWords)(unsafe.Pointer(v))
  10.     typ := LoadPointer(&vp.typ)
  11.     if typ == nil || uintptr(typ) == ^uintptr(0) {
  12.         // First store not yet completed.
  13.         return nil
  14.     }
  15.     data := LoadPointer(&vp.data)
  16.     xp := (*ifaceWords)(unsafe.Pointer(&x))
  17.     xp.typ = typ
  18.     xp.data = data
  19.     return
  20. }
  22. // Store sets the value of the Value to x.
  23. // All calls to Store for a given Value must use values of the same concrete type.
  24. // Store of an inconsistent type panics, as does Store(nil).
  25. func (v *Value) Store(x interface{}) {
  26.     if x == nil {
  27.         panic("sync/atomic: store of nil value into Value")
  28.     }
  29.     vp := (*ifaceWords)(unsafe.Pointer(v))
  30.     xp := (*ifaceWords)(unsafe.Pointer(&x))
  31.     for {
  32.         typ := LoadPointer(&vp.typ)
  33.         if typ == nil {
  34.             // Attempt to start first store.
  35.             // Disable preemption so that other goroutines can use
  36.             // active spin wait to wait for completion; and so that
  37.             // GC does not see the fake type accidentally.
  38.             runtime_procPin()
  39.             if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
  40.                 runtime_procUnpin()
  41.                 continue
  42.             }
  43.             // Complete first store.
  44.             StorePointer(&vp.data, xp.data)
  45.             StorePointer(&vp.typ, xp.typ)
  46.             runtime_procUnpin()
  47.             return
  48.         }
  49.         if uintptr(typ) == ^uintptr(0) {
  50.             // First store in progress. Wait.
  51.             // Since we disable preemption around the first store,
  52.             // we can wait with active spinning.
  53.             continue
  54.         }
  55.         // First store completed. Check type and overwrite data.
  56.         if typ != xp.typ {
  57.             panic("sync/atomic: store of inconsistently typed value into Value")
  58.         }
  59.         StorePointer(&vp.data, xp.data)
  60.         return
  61.     }
  62. }