前几天被小伙伴发现半年前写的代码里面有一个并发的bug。回想一下，golang并发这边的知识确实忘得差不多了，打算写两篇笔记记录一下。golang里的并发主要有两种，一种是使用goroutine（类似于线程）并通过channel实现线程间通信；另一种是通过shared variables来实现。我们先来看看第一种

goroutine

首先我们来看一个goroutine的例子

func main (){
  go func() {
    for i := 0; i < 10; i++ {
      fmt.Println("foo", i)
    }
  }()
  fmt.Println("bar")
}

上面的go foo()开了一个新的goroutine,但是它并不会跑完（可能能跑一两个循环），因为main先退出了，整个程序也就结束了。为了让它能够跑完，我们可以让main等一等它。

var wg sync.WaitGroup

func main (){
  wg.Add(1)
  go func() {
    defer wg.Done()
    for i := 0; i < 10; i++ {
      fmt.Println("foo", i)
    }
  }()
  fmt.Println("bar")
  wg.Wait()
}

为了显示他们是并发的，我们多开几个goroutine,看他们的输出是否是乱序的。

var wg sync.WaitGroup

func foo(s string){
  defer wg.Done()
  for i := 0; i < 10; i++ {
    fmt.Println(s, i)
  }
}

func main (){
  wg.Add(3)
  go foo("foo")
  go foo("oof")
  go foo("bar")
  wg.Wait()
}

有兴趣的同学可以看看net/http是如何使用goroutine的

Channels

"If goroutines are the activities of a concurrent go program, channels are the connections between them"
这句话是对channel最好的解释了。channel用于在goroutine之间传递值，是一种"线程"间通信方式。

ch := make(chan int)   //创建一个unbuffered channel
ch := make(chan int, 3) //创建一个buffered channel,容量为3
ch <- x  //发送值到channel
x = <- ch //从channel中取出值
<- ch //取值并丢弃
close(ch) //关闭channel

语法太简单了！这年头连编程语言都要拟物化了！

unbuffered channel

发送数据到unbuffered channel的操作会阻塞发送的goroutine,直到有某个线程接收了这个channel的值。而如果一个goroutine试图去一个没有值的channel上取值，它也会被阻塞，直到这个channel上被发送了值。

func main() {
  c := make(chan int)
  go func(c chan int) {
    time.Sleep(3 * time.Second)
    fmt.Println("before received")
    fmt.Println(<- c)
  }(c)
  c <- 1
  fmt.Println("after received")
}

运行上面代码我们明显看到，在channel中的值被读取之前，main被阻塞了，直到channel被读取，main才继续运行。

func main() {
  c := make(chan int)
  go func(c chan int) {
    fmt.Println(<- c)
    fmt.Println("after received")
  }(c)
  time.Sleep(3 * time.Second)
  fmt.Println("before sending")
  c <- 1
  time.Sleep(1 * time.Second)
}

上面的代码中，新开的goroutine首先去读channel,可是由于channel中没有值，所以它被阻塞了，直到main中向channel发送值，goroutine才拿到它想要的值并继续运行。

close channel

发送完成后，可以关闭channel，关闭后所有对这个channel的写操作都会panic,而读操作依旧可以进行，当所有值都读完后，继续读该channel会得到zero value

func main() {
  naturals := make(chan int)
  squares := make(chan int)

  go func() {
    for x := 0; x < 100 ;x++ {
      naturals <- x
    }
    close(naturals)
  }()

  go func() {
    for x := range naturals{
      squares <- x * x
    }
    close(squares)
  }()

  for x := range squares{
    fmt.Println(x)
  }
}

buffered channels

buffered channels是一个有限长队列，下面我们来创建一个容量为3的buffered channels

bc := make(chan int, 3)

如果bc里面已经有了三个没有被读取的值，继续往里面发送的话程序就会出错。我们可以用cap函数和len函数来检查bc的容量以及里面现在有几个值。