Go语言并发编程

1.并发和并行

并行（parallel）：指在同一时刻，有多条指令在多个处理器上同时执行。

并发（concurrency）：指在同一时刻只能有一条指令执行，但是多个进程指令被快速的轮换执行，使得宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替执行。

Go语言为并发编程而内置的上层API基于CSP(communicating  sequential  processes,顺序通信模型)模型。这就意味着显示锁都是可以避免的，因为Go语言通过安全的通道发送和接受数据以实现同步，这大大地简化了并发程序的编写。一般情况下，一个普通的计算机跑十几二十个线程就有点负载过大了，但是同样这台机器却可以轻松地让成百上千甚至上万个goroutine进行资源竞争。

2.goroutine

       goroutine是Go并发设计的核心。Goroutine说到底其实就是协程，但是他比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需要极少的栈内存（大概是4~5KB），当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。Goroutine比thread更易用、更高效、更轻便。

【1】创建一个goroutine

只需要在调用程序前面添加go关键字就可以创建一个协程。

package main

import "fmt"
import "time"

func newTask() {
	for {
		fmt.Println("this is a newTask")
		time.Sleep(time.Second) //延时一秒
	}
}
func main() {
	go newTask() //新建一个协程
	for {
		fmt.Println("this is a main goroutine")
		time.Sleep(time.Second) //延时一秒
	}
}

输出：

可以看到两个for循环在同时运行

【2】goroutine退出方式

主协程退出了，其他协程也要跟着退出。

package main

import (
	"fmt"
	"time"
)

//主协程退出了，子协程也要跟着退出

func main() {

	go func() {
		i := 0
		for {
			i++
			fmt.Println("子协程 i = ", i)
			time.Sleep(time.Second)

			if i == 2 {
				break
			}
		}
	}()
	i := 0
	for {
		i++
		fmt.Println("main i = ", i)
		time.Sleep(time.Second)

		if i == 2 {     //当主协程中i=2时，主协程退出
			break
		}
	}
}

输出：

可以看到主协程退出后子协程也退出了。

【3】runtime包

• Runtime.Gosched()用于让出CPU时间片，让出当前goroutine的执行权限，调度器安排其他等待的任务执行，并在下次某个时候从该位置恢复执行。就像接力赛，A跑了一会碰到代码runtime.Gosched()就把接力棒交给了B了，A就歇着了，B继续跑。

package main

import (
	"fmt"
	"runtime"
)

func main() {

	go func() {
		for i := 0; i < 2; i++ {
			fmt.Println("go")
		}
	}()

	for i := 0; i < 2; i++ {
		//让出时间片，先让别的协程执行，执行完后，再执行次协程
		runtime.Gosched()
		fmt.Println("hello")
	}
}

输出：

• 调用runtime.Goexit()立即终止当前goroutine，调度器确保所有已注册defer延迟调用被执行。

package main

import (
	"fmt"
	"runtime"
)

func test() {
	defer fmt.Println("cccccccccccccccccc")

	// return //终止次函数
	runtime.Goexit() //终止所在的协程
	fmt.Println("bbbbbbbbbbbbbbbb")
}

func main() {

	go func() {
		fmt.Println("aaaaaaaaaaa")

		//调用别的函数
		test()

		fmt.Println("dddddddddddd")
	}()
	//写一个死循环，让主协程不结束
	for {

	}
}

输出：

如果使用return输出为：

• 调用runtime.GOMAXPROCS()用来设置用来并行计算的CPU核数最大值，并返回之前的值。

package main

import (
	"fmt"
	"runtime"
)

func main() {
	n := runtime.GOMAXPROCS(1) //指定核数
	fmt.Println("n = ", n)

	for {
		go fmt.Print(1)
		fmt.Print(0)
	}
}

输出太多就不展示了，需要解释的是：

第一次执行（runtime.GOMAXPROCS(1)）时，最多同时只能有一个goroutine被执行。所以会打印很多一。过了一段时间后，GO语言调度器将其置为休眠，并唤醒另一个goroutine,这时候开始打印很多个0了，在打印的时候，goroutine是被调度到操作系统线程上的。

第二次执行(runtime.GOMAXPROCS(2))时，我们使用了两个CPU，所以两个goroutine可以一起被执行，以同样的频率交替打印0和1。

3.channel

        Goroutine运行在相同的地址空间，因此访问内存必须做好同步。Goroutine奉行通过通信来共享内存，而不是共享内存来通信。引用类型channel是CSP模式的具体实现，用于多个goroutine通讯。其内布实现了同步，确保并发安全。

      和map类似，channel也一个对应make创建的底层数据结构的引用。

      当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者和被调用者将引用同一个channel对象。和其他的引用类型一样，channel的零值也是nil。

【1】通过channel解决资源占用，实现同步

下面的代码会产生资源抢占

package main

import (
	"fmt"
	"time"
)

//打印机
func Printer(str string) {
	for _, data := range str {
		fmt.Printf("%c", data)
		time.Sleep(time.Second)
	}
	fmt.Println()
}

//person1执行完成之后，person2执行
func person1() {
	Printer("hello")
}

func person2() {
	Printer("world")
}

func main() {
	//创建两个协程，代表两个人，两个人同时使用打印机
	go person1()
	go person2()

	//特地不让主协程结束，死循环
	for {

	}
}

输出：

通过管道通信解决资源抢占问题

package main

import (
	"fmt"
	"time"
)

//全局变量，创建一个channel
var ch = make(chan int)

//打印机
func Printer(str string) {
	for _, data := range str {
		fmt.Printf("%c", data)
		time.Sleep(time.Second)
	}
	fmt.Println()
}

//person1执行完成之后，person2执行
func person1() {
	Printer("hello")
	/*
		 给管道写数据，只有当Printer("hello")执行完成之后，这句才会执行，person2中接收到管道中有
		数据，就不会阻塞，从而执行Printer("world")，从而解决资源抢占问题。
	*/
	ch <- 666
}

func person2() {
	<-ch //从管道取数据，接收，如果通道没有数据他就会阻塞
	Printer("world")
}

func main() {
	//创建两个协程，代表两个人，两个人同时使用打印机
	go person1()
	go person2()

	//特地不让主协程结束，死循环
	for {

	}
}

输出：

【2】通过channel实现同步和数据交互

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建channel
	ch := make(chan string)
	defer fmt.Println("主协程也结束")
	go func() {
		defer fmt.Println("子协程调用完毕")
		for i := 0; i < 2; i++ {
			fmt.Println("i = ", i)
			time.Sleep(time.Second)
		}
		ch <- "我是子协程，我工作完毕"
	}()
	str := <-ch //没有数据前，阻塞
	fmt.Println("str = ", str)
}

输出：

【3】无缓冲channel

       无缓冲的通道(unbuffered  channel)是指在接收前没有能力保存任何值的通道

       这种类型的通道要求发送goroutine和接收goroutine同时准备好，才能完成发送和接收操作。如果两个goroutine没有同时准备好，通道会导致限制性发送或接收操作的goroutine阻塞等待。

       这种通道进行发送和接收的交互行为为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。

       无缓冲的channel创建格式：

make(chan  Type) //等价于make(chan  Type, 0)

     如果没有指定缓冲区容量，那么该通道就是同步的，因此会阻塞到发送者准备好发送和接收者准备好接收。

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建一个无缓冲channel
	ch := make(chan int, 0)

	//len(ch)缓冲区剩余数据个数
	fmt.Printf("len(ch) = %d, cap(ch) = %d\n", len(ch), cap(ch))

	//创建协程
	go func() {
		for i := 0; i < 3; i++ {
			fmt.Println("子协程：i = ", i)
			ch <- i //往channel写内容
		}
	}()

	//延迟
	time.Sleep(2 * time.Second)

	for i := 0; i < 3; i++ {
		num := <-ch //从管道中读数据，没有内容前，阻塞
		fmt.Println("num = ", num)
	}
}

输出：

没有按照先i后num的原因是num还没来得及打印i就抢先打印了。

【4】有缓冲channel

       有缓冲的通道(buffered channel)是一种在被接收前能存储一个或者多个值的通道

      这种类型的通道并不强制要求goroutine之间必须同时完成发送和接收。通信会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

      这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的goroutine会在同一时间进行数据交换，有缓冲的通道没有这个保证。

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建一个有缓冲channel
	ch := make(chan int, 3)
	//ch := make(chan int, 1)
	//len(ch)缓冲区剩余数据个数
	fmt.Printf("len(ch) = %d, cap(ch) = %d\n", len(ch), cap(ch))

	//创建协程
	go func() {
		for i := 0; i < 3; i++ {
			ch <- i //往channel写内容
			fmt.Printf("子协程[%d]：len(ch) = %d, cap(ch) = %d\n", i, len(ch), cap(ch))
		}
	}()

	//延迟
	time.Sleep(2 * time.Second)

	for i := 0; i < 3; i++ {
		num := <-ch //从管道中读数据，没有内容前，阻塞
		fmt.Println("num = ", num)
	}
}

输出：

缓冲区大小为3：

缓冲区大小为1：

【5】关闭channel

package main

import (
	"fmt"
)

func main() {
	//创建一个无缓冲channel
	ch := make(chan int, 0)

	//创建一个goroutine
	go func() {
		for i := 0; i < 5; i++ {
			ch <- i //往通道写数据
		}
		close(ch)  //关闭通道
	}()

	for {
		//如果为true说明管道没有关闭
		if num, ok := <-ch; ok == true {
			fmt.Println("num = ", num)
		} else { //管道关闭
			break
		}
	}
}

输出：

【6】通过range遍历channel内容

package main

import (
	"fmt"
)

func main() {
	//创建一个无缓冲channel
	ch := make(chan int, 0)

	//创建一个goroutine
	go func() {
		for i := 0; i < 5; i++ {
			ch <- i //往通道写数据
		}
		close(ch)
	}()

	for num := range ch {
		fmt.Println("num = ", num)
	}
}

输出：

【7】单向管道

默认情况下，通道是双向的，也就是，既可以往里面发送数据也可以从里面接收数据。

但是，我们经常见一个通道作为参数进行传递而值希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。

• chan<-表示数据进入管道，要把数据写入管道，对于调用者就是输出
• <-chan表示数据从管道出来，对于调用者就是得到管道的数据，当然就是输入。

单向channel的特性验证：

package main

func main() {
	//创建一个channel，双向的
	ch := make(chan int)

	//双向channel能隐式转换为单向channel
	var writeCh chan<- int = ch //只能写，不能读
	var readCh <-chan int = ch  //只能读，不能写

	writeCh <- 666 //写

	<-readCh //读
	//单向无法转化为双向
}

单向channel的应用：

package main

import (
	"fmt"
)

//此管道只能写不能读
func producter(out chan<- int) {
	for i := 0; i < 10; i++ {
		out <- i * i
	}
	close(out)
}

//此管道只能读不能写
func consumer(in <-chan int) {
	for num := range in {
		fmt.Println("num = ", num)
	}
}

func main() {
	//创建一个双向通道
	ch := make(chan int)

	//生产者，生产数字，写入channel
	go producter(ch) //channel传参，引用传递

	//消费者，从channel读取内容，打印
	consumer(ch)
}

输出：

4.定时器

•        Timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间，它提供一个channel，在将来的那个时间那个channel提供了一个时间值。

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建一个定时器，设置时间为2s，2s后，往time通道写内容（当前时间）
	//timer只会执行一次
	timer := time.NewTimer(2 * time.Second)

	fmt.Println("当前时间:", time.Now())
	//2s后，往timer.C写数据，有数据后，就可以读取
	t := <-timer.C
	fmt.Println("t = ", t)
}

输出：

通过timer实现延时：

package main

import (
	"fmt"
	"time"
)

func main() {
	//延时两秒后打印一句话
	/*
		下面两句等价于time.Sleep(2*time.Second)
		也等价于<-time.After(2*time.Second) //定时两秒，阻塞两秒，2s后产生一个事件，往channel写内容
	*/
	timer := time.NewTimer(2 * time.Second)
	<-timer.C
	fmt.Println("时间到")
}

输出：

停止定时器：

package main

import (
	"fmt"
	"time"
)

func main() {
	timer := time.NewTimer(3*time.Second)
	go func() {
		<-timer.C
		fmt.Println("子协程可以打印了，因为定时器的时间到")
	}()
	
	timer.Stop()//停止定时器
	for {
		
	}
}

重置定时器：

package main

import (
	"fmt"
	"time"
)

func main() {
	timer := time.NewTimer(3 * time.Second)
	timer.Reset(1 * time.Second) //重置计时器
	<-timer.C
	fmt.Println("时间到")
}

输出：

•        Ticker是一个定时触发的计时器，他会以一个间隔（interval）往channel发送一个事件（当前时间）,而channel的接收者可以以固定的时间间隔从chnanel中读取事件。

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建定时器，每隔1秒后，定时器就会给channel发送一个时间（当前时间）
	ticker := time.NewTicker(2 * time.Second)
	i := 0
	go func() {
		for {
			i++
			<-ticker.C
			fmt.Println("时间到")
			if i > 5 {
				ticker.Stop() //停止定时器
			}
		}
	}()

	for {

	}
}

输出：

5.select

       Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。

       Select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。与switch语句可以选择任何人可使用相等的比较条件相比，select有比较多的限制，其中最大的一条限制就是每个case语句里必须有一个IO操作。在一个select语句中，GO语言会按顺序从头至尾评估每一个发送和接收的语句。如果其中的任意一个语句可以继续执行（即没有被阻塞），那么就从那些可以执行的语句中任意选择一条来使用。

       如果没有任意一条语句可以执行（即所有的通道都被阻塞），那么有两种情况：

• 如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。
• 如果没有default语句，那么select语句将被阻塞，直到至少有一个可以进行下去。

package main

import (
	"fmt"
)

func fibonacci(ch chan<- int, quit <-chan bool) {
	x, y := 1, 1
	for {
		//监听channel数据的流动
		select {
		case ch <- x:
			x, y = y, x+y
		case flag := <-quit:
			fmt.Println("flag = ", flag)
			return
		}
	}
}
func main() {
	ch := make(chan int)    //数字通信
	quit := make(chan bool) //程序是否结束

	//消费者，从channel读取内容
	//新建协程
	go func() {
		for i := 0; i < 8; i++ {
			num := <-ch
			fmt.Println(num)
		}
		//可以停止
		quit <- true
	}() 
	//生产者，产生数字，写入channel
	fibonacci(ch, quit)
	
}

输出：

有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下方式实现：

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int)
	flag := make(chan bool)

	go func() {
		for {
			select {
			case v := <-ch:
				fmt.Println(v)
			case <-time.After(5 * time.Second):
				fmt.Println("timeout")
				flag <- true
			}
		}
	}()

	<-flag
	fmt.Println("程序结束")
}

输出：