《7天学会Go并发编程》第四天 sync.Once和sync.WaitGroup学习应用实践

??并发编程当总是会遇到一些线程调度的问题。

有A,B,C,D四个线程，需要确保在A,B,C执行结束后，再执行D线程。比如写一段Fan-In，多表融合的代码，A,B,C从独立的三表中抽取出数据，在线程D中进行融合。那么在这个过程中，如果ABC线程数据抽取未完成，D就开始进行数据融合，势必造成数据融合结果的缺失，不完整。

单线程的单次执行，也就是说这个线程只能执行一次。比如循环判断一个条件是否满足，满足以后执行单次执行，避免重复执行。例如金额的累加，判断累加值以后，不论成功与否，只执行一次。

???今天针对上述问题，重点介绍一下go语言中的waitgroup和once。

目录

一、sync.waitGroup

二、??sync.Once的使用

2.1??? 多次调用，仅执行一次

三、???Sync.Once和WaitGroup的并发使用

下面这段是一个联合使用错误的代码：

三、???总结

---

一、sync.waitGroup

waitGroup的功能就是阻塞等待一组线程执行结束。具体的使用方法就是新开一个需要等待的线程，就在需要等待的线程数上增1。对应的线程执行结束后，就调用done函数。同时，执行等待的线程调用wait函数，阻塞等待直至所有的线程执行完毕。

可以举一个例子就是现在有5个小朋友需要联机打游戏，必须要等待五个小朋友都加入游戏，并且准备完成才可以开局，如果有小朋友没有准备完成，那么游戏就不能开始。那么新来一个小朋友，就意味着需要等待一个小朋友完成游戏准备，直至等到所有的小朋友准备完成后，才可以开始游戏。这个等待过程就是一个阻塞过程。

示例代码如下：

使用waitGroup实现主线程等待线程1,2,3执行完毕后，主线程再打印。

 	group := sync.WaitGroup{}//waitGroup的初始化
 	fmt.Printf("所有结果显示
")
	group.Add(1) //新开启一个线程，就需要在等待函数中加1.
	go func() {
		defer group.Done()//对应的线程执行结束后，需要调用done函数
	     fmt.Println("线程1")
	}()
	group.Add(1)
	go func() {
		defer group.Done()
		fmt.Println("线程2")
	}()
	group.Add(1)
	go func() {
		defer group.Done()
		fmt.Println("线程3")
	}()
	group.Wait()//主线程在这阻塞等待上面所有的线程执行完毕
	fmt.Printf("所有线程运行结束
")

代码执行结果如下：

下面实现一个不适用waitGroup阻塞等待后的代码执行示例：

func main() {
 	group := sync.WaitGroup{}
 	fmt.Printf("所有结果显示
")
	group.Add(1)
	go func() {
		defer group.Done()
	     fmt.Println("线程1")
	}()
	group.Add(1)
	go func() {
		defer group.Done()
		fmt.Println("线程2")
	}()
	group.Add(1)
	go func() {
		defer group.Done()
		fmt.Println("线程3")
	}()
	//group.Wait() 注释掉阻塞等待代码
	fmt.Printf("所有线程运行结束
")
}

代码对应的执行结果:

可以明显的看出，不使用阻塞代码后，程序直接执行完主线程后，并没有进行等待。

总结：使用waitGroup时，需要注意线程等待数和对应的线程执行结束后的done函数调用，最最重要的是增加wait函数阻塞。

二、??sync.Once的使用

Once的功能见名知意，就是实现一个函数或者一个功能只执行一次。

2.1??? 多次调用，仅执行一次

下面的代码实现了两次对变量I进行自加操作。

func initOnceFunc() {
	once := sync.Once{}
	i := 1
	once.Do(func() {
		i++
	})
	once.Do(func() {
		i++
	})
	fmt.Printf("current value is %d", i)
}

对应的输出：

从结果可以看出来，这个自加操作仅执行了一次。这就说明一个once对象仅会对其传入的func执行一次。

---

原因就是：

Once的结构中有一个done的属性，这个Once执行后，Done就会标记这个Once被使用过，后续传入的func(){}就不会再被调用。

三、???Sync.Once和WaitGroup的并发使用

下面这段代码实现主线程阻塞等待所有线程并发执行once。

感兴趣的可以???♀???♀

func waitGroupCorrect() {
	once := sync.Once{}
	group := sync.WaitGroup{}
	i := 1
	group.Add(1)

	go func() {
		defer group.Done()
		go once.Do(func() {
			i++
		})
	}()
	group.Add(1)
	go func() {
		defer group.Done()
		go once.Do(func() {
			i++
		})
	}()
	group.Add(1)
	go func() {
		defer group.Done()
		go once.Do(func() {
			i++
		})
	}()
	group.Wait()
	fmt.Printf("current value is %d", i)
}

下面这段是一个联合使用错误的代码：

可以和上面对比一下，为什么会报错哟

func waitGroup() {
	once := sync.Once{}
	group := sync.WaitGroup{}
	i := 1
	group.Add(1)
	go once.Do(func() {
		defer group.Done()
		i++
	})
	group.Add(1)
	go once.Do(func() {
		defer group.Done()
		group.Add(1)
		i++
	})
	group.Wait()
	fmt.Printf("current value is %d", i)
}

三、???总结

今天介绍了一下，waitGroup和Once的联合使用，后面想讲一下context的使用，还需要再琢磨琢磨。后续的文章中，会继续拓展、深化go并发编程原理和生产案例???~

???感谢诸位大佬的阅读，点个关注，收藏一下呗~