go基础——并发

内容

1 goroutin间通信
2 管道使用
3 锁
4 原子操作
5 sync包使用

一、goroutine间通信

goroutine间的通信方式主要有：利用管道、共享变量

二、管道使用

1 channel申明

    var chan1 chan int: 申明了一个没有缓存的双向管道「双向：可写入 可读取」
    var chan1 chan<- int: 申明了一个没有缓存，只可以写入的管道
     var chan1 <-chan int: 申明了一个没有缓存，只可以读取的管道
    chan1 := make(chan int, 2): 初始化了一个容量为2的信道，chan1是这个信道的引用
    chan1 := make(chan<- int, 2):初始化了一个容量为2的只可写入的单项信道

2 信道的阻塞
当信道为空时或是信道到达了其容量的最大值是，会堵塞

func main()  {
 chan1 := make(chan int)
 <- chan1 //堵塞在这里，下面block永远不会打印
 println("bolck")
}

func main()  {
 chan1 := make(chan int, 2)
 
 chan1<- 1
 chan1<- 2
 println("bolck")
 chan1<-3 // 会阻塞在这里，block2永远不会打印，除非有其他协程读取管道值
 println("block2")
}

3 select语句
select语句的使用很像是switch，不过select是专门配到信道来使用的，select会堵塞在select语句上，除非有一个信道有值输入，当然如果有defalut，且没有任何一个信道准备好时，就会执行default语句了

func main()  {
   chan1 := make(chan int, 2)
   chan2 := make(chan int, 3)
   chan1<-1
   chan2<-2
   // 多次执行，chan1和chan2都会出现，当信道都准备好的时候，会随机执行一个case
   select {
   case <-chan1:
      println("chan1")
   case <-chan2:
      println("chan2")
   }
}

// 当没有任何一个信道准好的时候，会执行default
func main()  {
   chan1 := make(chan int, 2)
   chan2 := make(chan int, 3)

   select {
   case <-chan1:
      println("chan1")
   case <-chan2:
      println("chan2")
   default:
      println("defalut")
   }
}

三、锁

1 互斥锁
go中通过sync.Mutex的零值来表示一个没有被锁定的互斥量，开箱即用，申明一个变量就可以用，但是如果把互斥量当做入参传入到函数中使用时，只能传递指针，不能是值传递，值传递是拷贝，不能达到锁住的作用。

var x int 
func main()  {
var m sync.Mutex
add(&m, 2)
}

// 同步的做甲方
func add(m *sync.Mutex, value int){
m.Lock()
x = x + value
m.Unlock()
}

2 读写锁
go中通过sync.RWMutex的零值来表示一个读写锁实例，读写锁中有两对方法，分别是读锁定和读解锁、写锁定和写解锁
规则：读写锁下，多个写操作之间是互斥的，写操作和读操作之间也是互斥的，但是多个读操作之间不存在互斥关系

rw.Lock() // 写锁定
rw.Unlock()
rw.RLock() // 读锁定
rw.RUnlock()

func main()  {
   var rw sync.RWMutex
   go func() {
      rw.RLock()
      println(1)
      time.Sleep(2*time.Second)
      rw.RUnlock()
      println(2)
   }()
   time.Sleep(1*time.Second)
   println(3)
    // 被堵在这里，因为协程中 rw.RLock()加了读锁，会阻塞写锁，不会堵塞其他协程获取读锁，rw.RUnlock()执行后，释放了读锁，同样也会释放写锁，前提是已经没有任何其他的读锁了；如果是先执行rw.Lock()，同样也会堵塞其他写锁和读锁，rw.Ulock()会把读锁和写锁全部释放
   rw.Lock()
   println(4)
}

四、原子操作

Go中sync/Atomic包中提供了原子的操作，原理还是基于CAS算法来实现的

五、sync包使用

1 sync.Once

 var once sync.Once //同样开箱即用
// Do方法接收一个无参数、无结果的函数作为参数，保证这个方法只执行一次
 Once.Do(func(){
    fmt.println(“func方法只执行一次")
})

// 原理是Once结构体内维护了一个无符号的变量done，当执行一次func后会原子的加1，如果done不会0时，就不会执行func了

func (o *Once) Do(f func()) {
   if atomic.LoadUint32(&o.done) == 0 {
      // Outlined slow-path to allow inlining of the fast-path.
      o.doSlow(f)
   }
}
func (o *Once) doSlow(f func()) {
   o.m.Lock()
   defer o.m.Unlock()
   if o.done == 0 {
      defer atomic.StoreUint32(&o.done, 1)
      f()
   }
}

2 sync.WaitGroup
wg会阻塞在wait()方法上，等待一组协程执行结束，同样是开箱即用，同样在函数中当做入参传递时，记住传递指针

func main()  {
   var wg sync.WaitGroup
   wg.Add(1)
   go func() {
      println(1)
      wg.Done()
   }()

   //主协程阻塞在这里，必定会等协程中执行完毕后，才会执行打印2
   wg.Wait()
   println(2)
}
    ```