Go语言工程进阶-并发编程

这是我参与「第五届青训营 」笔记创作活动的第 3 天

前言

基于前文的 Go 语言基础语法，本文主要介绍 Go 语言进阶编程中的并发编程，从并发编程的视角介绍 Go 语言高性能的本质。

重点内容

• 协程 Goroutine

• 通道 Channel

• 锁 Lock

• 线程同步 WaitGroup

知识点介绍

Go 语言可以充分发挥多核优势

协程 Goroutine

协程运行在线程之上，协程并没有增加线程数量，只是在线程的基础之上通过分时复用的方式运行多个协程，而且协程的切换在用户态完成，切换的代价比线程从用户态到内核态的代价小很多。

创建一个协程非常简单，就是在一个任务函数前面添加一个 go 关键字：

go func()

下面一个示例：

// 打印 hello goroutine : 0 - 4
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)
	}
	time.Sleep(time.Second)
}

结果并不是顺序打印出来，可见不同协程并发执行，顺序不同。

通道 Channel

Go 提供一种称为通道的机制，用于在 Goroutine 之间共享数据，保证协程在执行并发活动时同步交换数据，在同一时刻只有一个协程可以访问通道数据项。

通道包括：

• 无缓冲通道：同步通信

unBuf := make(chan int)

• 有缓冲通道：异步通信

buf := make(chan int, 10)

利用协程和通道完成一个生产者消费者模型：a 子协程发送数字0-9，b 子协程计算数字的平方，主协程输出最后的平方数

func CalSquare() {
	src := make(chan int)
	dest := make(chan int, 3)
	go func() {
		defer close(src)
		for i := 0; i < 10; i++ {
			src <- i
		}
	}()
	go func() {
		defer close(dest)
		for i := range src {
			dest <- i * i
		}
	}()
	for i := range dest {
		//复杂操作
		println(i)
	}
}

利用 for range 从通道中读取数据，利用 <- 向通道内写数据。

锁 Lock

在有两个或更多 goroutine 的程序中，每一个 goroutine 内的语句也是按照既定的顺序去执行的，但是一般情况下没法去知道分别位于两个 goroutine 的事件 x 和 y 的执行顺序，x 是在 y 之前还是之后还是同时发生是没法判断的。当没有办法自信地确认一个事件是在另一个事件的前面或者后面发生的话，就说明 x 和 y 这两个事件是并发的。

并发编程很容易出现竞争，一般通过加锁的方式实现同步

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)
}

线程同步 WaitGroup

Go语言中除了可以使用通道（channel）和互斥锁进行两个并发程序间的同步外，还可以使用等待组进行多个任务的同步，等待组可以保证在并发环境中完成指定数量的任务。

WaitGroup 一共有三个方法

• Add 方法用于设置 WaitGroup 的计数值，可以理解为子任务的数量

• Done 方法用于将 WaitGroup 的计数值减一，可以理解为完成一个子任务

• Wait 方法用于阻塞调用者，直到 WaitGroup 的计数值为0，即所有子任务都完成

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()
}

总结

本文主要介绍了 Go 语言并发编程的相关知识，为了应对高访问量，现代系统大都采用并发编程，Go 语言又是为并发编程所生，因此这部分知识需要熟练掌握，应用于后续大作业。