18. 并发

学到什么

1. 并发与并行的区别？

2. 什么是 Goroutine？

3. 什么是通道？

4. Goroutine 如何通信？

5. 相关函数的使用？

6. select 语句如何使用？

并发与并行

• 你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。

• 你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。

• 你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。

什么是 Goroutine

main Goroutine

package main

func main() {
	panic("看这里")
}

panic: 看这里

goroutine 1 [running]:
main.main()

创建 Goroutine

go fun1(...)

go func(...){
	// ...
}(...)

• go 关键字后的函数可以写返回值，但无效。因为 Goroutine 是异步的，所以没法接受。

package main

import (
	"fmt"
)

func PrintA()  {
	fmt.Println("A")
}

func main() {
	go PrintA()
	fmt.Println("main")
}

• 第一行：创建一个 Goroutine，异步打印“A”字符串。

• 第二行：打印 “main” 字符串。

main

func main() {
	go PrintA()
	fmt.Println("main")
	time.Sleep(time.Second)
}
// 输出
main
A

func main() {
   go PrintA()
   fmt.Println("main")
   select {}
}

// 输出
main
A
fatal error: all goroutines are asleep - deadlock!
...

• 爬虫项目，创建了 Goroutine，需要一直爬取数据，不需要停止。

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func PrintA()  {
	fmt.Println("A")
	wg.Done()
}

func main() {
	wg.Add(1)

	go PrintA()

	wg.Wait()
	fmt.Println("main")
}

• 声明 WaitGroup 类型变量 wg，使用时无需初始化。

• wg.Add(1) 表示需要等待一个 Goroutine，如果有两个，使用 Add(2)。

• 当一个 Goroutine 运行完后使用 wg.Done() 通知。

• wg.Wait() 等待 Goroutine 执行完。

控制并发数

num := 2
runtime.GOMAXPROCS(num)

什么是通道

创建通道

1. 无缓冲

strChan := make(chan string)

allChan := make(chan interface{})

strChan := make(chan string)
strChan <- "老苗"

// concurrency/channel/main.go
package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func Read(strChan chan string)  {
	data := <-strChan
	fmt.Println(data)
	wg.Done()
}

func main() {
	wg.Add(1)

	strChan := make(chan string)
	go Read(strChan)
	strChan <- "老苗"

	wg.Wait()
}

// 输出
老苗

• Read 函数负责读取通道数据，并打印。

• 通道是引用类型，因此传递时无需使用指针。

• <-strChan 表示从通道里拿数据，如果通道里没有数据它会进行阻塞。

• wg.Wait() 等待 Read 异步函数执行完。

2. 有缓冲

bufferChan := make(chan string, 3)

• 创建了一个存储数据类型为 string 的通道。

• 可以缓冲 3 个数据，即给通道送入 3 个数据不会进行阻塞。

// concurrency/bufferchannel/main.go
package main

import "fmt"

func main() {
	bufferChan := make(chan string, 3)
	bufferChan<-"a"
	bufferChan<-"b"
	bufferChan<-"c"

	fmt.Println(<-bufferChan)
}

// 输出
a

• 给 bufferChan 变量存入 3 个字符串。

• 存入 3 个数据时不会阻塞，当存入数量超过 3 时，就需要 Goroutine 异步读取。

• bufferChan 长度为 3 的缓冲通道，并且已存入 2 个数据。

• 看图中的两个箭头，箭头在 bufferChan 右边，表示存，左边表示取。

• 按照先入先出规则存取。

单向通道

readChan := make(<-chan string)

writeChan := make(chan<- string)

• readChan 只能读取数据。

• writeChan 只能存取数据。

// concurrency/onechannel/main.go
package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

// 写通道
func write(data chan<- int)  {
	data<-520
	wg.Done()
}

// 读通道
func read(data <-chan int)  {
	fmt.Println(<-data)
	wg.Done()
}

func main() {
	wg.Add(2)

	dataChan := make(chan int)

	go write(dataChan)
	go read(dataChan)

	wg.Wait()
}

// 输出
520

• 创建了两个 Goroutine，read 函数负责只读，write 函数负责只写。

• 通道传递时，将双向通道转化为单向通道。

遍历通道

func write(data chan<- int)  {
	for i := 0; i < 10; i++ {
		data<-i
	}
	wg.Done()
}

1. 死循环

func read(data <-chan int)  {
	for {
		d := <-data
		fmt.Println(d)
	}
	wg.Done()
}

func write(data chan<- int)  {
	// ...
	close(data)
	wg.Done()
}

func read(data <-chan int)  {
	for {
		d, ok := <-data
		if !ok {
			break
		}
		fmt.Println(d)
	}
	wg.Done()
}

• ok 变量为 false 时，表示通道已关闭。

• 关闭通道后，ok 变量不会立马变成 false，而是等已放入通道的数据都读取完。

ch := make(chan string, 1)
ch <- "a"
close(ch)
val, ok := <-ch
fmt.Println(val, ok)

val1, ok1 := <-ch
fmt.Println(val1, ok1)

// 输出
a true
 false

2. for-range

func read(data <-chan int)  {
	for d := range data{
		fmt.Println(d)
	}
	wg.Done()
}

• 如果想退出 for-range 语句，也需要关闭通道。

• 如果关闭通道后，不需要增加 ok 判断，等通道数据读取完，自行会退出。

通道函数

ch := make(chan int, 3)
ch<-1

fmt.Println(len(ch))
fmt.Println(cap(ch))

// 输出
1
3

select 语句

• case 分支只能是“读通道”或“写通道”，如果读写成功，即不阻塞，则 case 分支就满足。

• fallthrough 关键字不能使用。

1. 无 default 分支

// concurrency/select/main.go
package main

import "fmt"

func main() {
   ch1 := make(chan int, 1)
   ch2 := make(chan int, 1)
   ch1 <- 1

   select {
   case v, ok := <-ch1:
      if ok {
         fmt.Println("ch1通道", v)
      }
   case v, ok := <-ch2:
      if ok {
         fmt.Println("ch2通道", v)
      }

   }
}

// 输出
ch1通道 1

• ch1 通道有数据，因此进入了第一个 case 分支。

• 这里展示了读通道，也可以给通道写数据，例：case ch2<-2。

• 如果删除 ch1 <- 1 ，select 语句会在 main 函数中一直等待，因此会造成死锁。

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [select]:
main.main()
	C:/workspace/go/src/gobasic/cocurrency/select/main.go:9 +0xe7

2. 有 default 分支

// ...
func main() {
	ch1 := make(chan int, 1)
	ch2 := make(chan int, 1)

	select {
	case v, ok := <-ch1:
		if ok {
			fmt.Println("ch1通道", v)
		}
	case v, ok := <-ch2:
		if ok {
			fmt.Println("ch2通道", v)
		}
	default:
		fmt.Println("没有可读写通道")
	}
}

// 输出
没有可读写通道

总结

• 在函数调用前增加 go 关键字，表示创建 Goroutine。

• 执行 Goroutine 不会同步等待，常用的使用 WaitGroup 类型处理。

• Goroutine 的通信使用通道传输。

• 无缓冲的通道，不要进行同步读写，不然会阻塞。