这是我参与「第三届青训营 -后端场」笔记创作活动的第2篇笔记

1.语言进阶--并发编程

Goroutine通过高效的调度模型，实现协程的高并发操作 Channel提倡通过通信实现共享内存 Sync（lock并发安全操作 wiatgroup实现协程间同步）

并发与并行

并发： 多线程程序在一个核的CPU上运行。单核CPU中，为了实现多个程序同时运行的假象，通常以时间片调度方式，让每个进程每次执行一个时间片，时间片用完就切换下一进程。由于时间片很短，一段时间内就有多个进程执行。

并行： 多线程程序在多个核的CPU上运行真正的多个程序同时执行，只能在多核CPU上

Goroutine 协程：用户态,轻量级线程，栈KB级别线程：内核态，线程跑多个协程，栈MB级别

package concurrence

import (
   "fmt"
   "time"
)

func hello(i int) {
   println("hello goroutine : " + fmt.Sprint(i))
}

func HelloGoRoutine() {
   for i := 0; i < 5; i++ {
      go func(j int) {
         hello(j)
      }(i)
   }
   //暴力通过sleep加阻塞，保证协程在执行完之前，主线程不退出
   time.Sleep(time.Second)
}

package concurrence

import "testing"

func TestManyGo(t *testing.T) {
      HelloGoRoutine()
}

协程之间通信

CSP(Communicating Sequential Processes)通信顺序进程，是一种并发编程模型，通过channel共享内存

go也保存着通过共享内存实现通信的机制，对于通过共享内存实现通信，对于多访问需要实现加锁，会影响到程序性能

channel 是一种引用类型，创建需要通过make关键字无缓冲通道（同步通道）:使得发送的goroutine和接收的goroutine之间同步化有缓冲通道（生产消费模型）：带有缓冲区，可以解决无缓冲通道的同步问题

src实现了A,B协程间的通信，无缓冲通道，保证了顺序性 desc 使用带缓冲的通道是因为消费者的消费速度较慢（打印），减少由于消费者的消费速度，影响到生产者的执行效率

package concurrence

import "fmt"

func CalSquare() {
   src := make(chan int)
   dest := make(chan int, 3)
   //A子协程发送0~9数字
   //
   go func() {
      defer close(src)
      for i := 0; i < 10; i++ {
         src <- i
      }
   }()
   //B子协程计算输入数字的平方
   go func() {
      defer close(dest)
      for i := range src {
         dest <- i * i
      }
   }()
   //主协程输出最后的平方数
   for i := range dest {
      fmt.Println(i)
   }
}

保留了共享内存实现通信

package concurrence

import (
   "sync"
   "time"
)

var (
   x    int64
   lock sync.Mutex
)

func addWithLock() {
   for i := 0; i < 2000; i++ {
      lock.Lock()
      x += 1
      lock.Unlock()
   }
}
func addWithoutLock() {
   for i := 0; i < 2000; i++ {
      x += 1
   }
}

func Add() {
   x = 0
   for i := 0; i < 5; i++ {
      go addWithoutLock()
   }
   time.Sleep(time.Second)
   println("WithoutLock:", x)
   x = 0
   for i := 0; i < 5; i++ {
      go addWithLock()
   }
   time.Sleep(time.Second)
   println("WithLock:", x)
}

func ManyGoWait() {
   var wg sync.WaitGroup
   wg.Add(5)
   for i := 0; i < 5; i++ {
      go func(j int) {
         defer wg.Done()
         hello(j)
      }(i)
   }
   wg.Wait()
}