原子操作

Go语言运行时调度系统会恰当安排所有goroutine的运行，在同一时刻，只可能有少数goroutine处于运行状态，并且这个数量只会与M的数量一致，而不会睡着G的增多而增多
_
为了公平起见，Golang调度器会频繁的换上或换下这些goroutine

  • 换上： 将goroutine由非运行状态转换为运行状态，并促使其中其中的代码在某个GPU上运行
  • 换下： 使一个goroutine中的代码中断执行，并让它的运行状态转换为非运行状态

**

原子操作有哪些？


sync/atomic包中函数可以做的原子操作有：加法（add）、比较并交换（cas）、加载（load）、存储（store）和交换（cap）

  • 原子操作函数需要的是被操作值的指针，而不是值本身
  • 原子加法操作函数可以做原子减法操作

sync/atomic.Value

  • atomic.Value 属于结构体类型，结构体类型属于值类型
  • 不能使用原子值存贮nil
  • 向原子值存储的第一个值，决定它以后能且只能存储哪一个类型的值
  • 如果有可能的话最好将原子值存储到结构体中，这样可以通过验证类型以防存储的原子操作因为类型报错
  • 尽量不要向原子值存储引用类型的值 （如切片、字典、通道是引用类型的值），造成安全漏洞
  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6.     "os"
  7.     "sync/atomic"
  8.     "errors"
  9.     "io"
  10. )
  12. func main() {
  13.     demo()
  14. }
  16. func demo() {
  17.     // Demo 1
  18.     fmt.Println("Demo 1")
  19.     var box atomic.Value    
  20.     fmt.Println("Copy box to box2")
  21.     box2 := box
  22.     v1 := [...]int{1,2,3}
  23.     fmt.Printf("Store %v to box.\n", v1)
  24.     box.Store(v1)
  25.     fmt.Printf("The value load from box is %v.\n", box.Load())
  26.     fmt.Printf("The value load from box2 is %v.\n", box2.Load())
  27.     fmt.Println()
  29.     // Demo 2
  30.     v2 := "123"
  31.     fmt.Printf("Store %q to box2.\n", v2)
  32.     box2.Store(v2)
  33.     fmt.Printf("The value load from box is %v.\n", box.Load())
  34.     fmt.Printf("The value load from box2 is %v.\n", box2.Load())
  35.     fmt.Println()
  37.     // Demo 3
  38.     fmt.Println("Copy box to box3.")
  39.     box3 := box
  40.     fmt.Printf("The value load from box3 is %v.\n", box3.Load())
  41.     v3 := 123
  42.     fmt.Printf("Store %d to box2.\n", v3)
  43.     // box3.Store(v3)
  44.     _ = box3
  45.     fmt.Println()
  47.     // Demo4
  48.     var box4 atomic.Value
  49.     v4 := errors.New("something wrong")
  50.     fmt.Printf("Store an error with message %q to box4.\n", v4)
  51.     box4.Store(v4)
  52.     v41 := io.EOF
  53.     fmt.Println("Store a value of the same type to box4.")
  54.     box4.Store(v41)
  55.     v42, ok := interface{}(&os.PathError{}).(error)
  56.     if ok {
  57.         fmt.Printf("Store a value of type %T that implements error interface to box4.\n", v42)
  58.         // box4.Store(v42)
  59.     }
  60.     fmt.Println()
  62.     // Demo5
  63.     fmt.Println("Demo5")
  64.     box5, err := NewAtomicValue(v4)
  65.     if err != nil {
  66.         fmt.Printf("error: %s\n", err)
  67.     }
  68.     fmt.Printf("The legal type n box5 is %s.\n", box5.TypeOfValue())
  69.     fmt.Println("Store a value of the same type to box5.")
  70.     err = box5.Store(v41) // 将原子值存储到结构体中，自定义存储操作
  71.     if err != nil {
  72.         fmt.Printf("error: %s\n", err)
  73.     }
  74.     fmt.Printf("Store a value of type %T that implemetns error interface to box5.\n", v42)
  75.     err = box5.Store(v42)
  76.     if err != nil {
  77.         fmt.Printf("errors: %s\n", err)
  78.     }
  79.     fmt.Println()
  81.     // Demo6
  82.     fmt.Println("Demo6")
  83.     var box6 atomic.Value
  84.     v6 := []int{1,2,3}
  85.     fmt.Printf("Store %v to box6.\n", v6)
  86.     box6.Store(v6)
  87.     v6[1] = 4 // 造成安全漏洞
  88.     fmt.Printf("The value load from box6 is %v.\n", box6.Load())
  90.     v6 = []int{1,2,3}
  91.     store := func(v []int) {
  92.         replica := make([]int, len(v))
  93.         copy(replica, v)
  94.         box6.Store(replica)
  95.     }
  96.     fmt.Printf("Store %v to box6.\n", v6)
  97.     store(v6)
  98.     v6[2] = 5
  99.     fmt.Printf("The value load from box6 is %v.\n", box6.Load())
  100. }
  102. type atomicValue struct {
  103.     v atomic.Value
  104.     t reflect.Type
  105. }
  107. func NewAtomicValue(example interface{}) (*atomicValue, error){
  108.     if example == nil {
  109.         return nil, errors.New("atomic value: nil example")
  110.     }
  111.     return &atomicValue{
  112.         t: reflect.TypeOf(example),
  113.     }, nil
  114. }
  116. func (av *atomicValue) Store(v interface{}) error {
  117.     if v == nil {
  118.         return errors.New("atomic value: nil value")
  119.     }
  120.     t := reflect.TypeOf(v)
  121.     if t != av.t {
  122.         return fmt.Errorf("atomic value: wrong type: %s", t)
  123.     }
  124.     av.v.Store(v)
  125.     return nil
  126. }
  128. func (av *atomicValue) Load() interface{} {
  129.     return av.v.Load()
  130. }
  132. func (av *atomicValue) TypeOfValue() reflect.Type {
  133.     return av.t
  134. }