【启程Golang之旅】协程和管道操作

欢迎来到Golang的世界！在当今快节奏的软件开发领域，选择一种高效、简洁的编程语言至关重要。而在这方面，Golang（又称Go）无疑是一个备受瞩目的选择。在本文中，带领您探索Golang的世界，一步步地了解这门语言的基础知识和实用技巧。

目录

初识协程

启动多协程

初识锁

初识管道

协程与管道协同

初识协程

在go语言中，”协程”（coroutine）通常指的是go的轻量级线程，也被称为goroutine，它使得并发编程变得更加简单和高效。这里我先对go语言中其他概念进行一个简单叙述：

1）程序(program)

是为完成特定任务、用某种语言编写的一组指令的集合，是一段静态的代码(程序是静态的)

2）进程(process)

是程序的一次执行过程，正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。(进程是动态的）是一个动的过程，进程的生命周期：有它自身的产生、存在和消亡的过程

3）线程(thread)

进程可进一步细化为线程，是一个程序内部的一条执行路径，若一个进程同一时间并行执行多个线程，就是支持多线程的。

4）协程(goroutine)

又称为微线程，纤程，协程是一种用户态的轻量级线程

与传统的线程相比，goroutine非常轻量，它们的创建和销毁成本很低，因此可以大量创建而不会对系统造成太大的负担，因此它是go实现高效并发编程的核心机制之一。

协程的作用：在执行A函数的时候，可以随时中断，去执行B函数，然后中断继续执行A函数(可以自动切换)，注意这一切换过程并不是函数调用（没有调用语句)，过程很像多线程，然而协程中只有一个线程在执行 (协程的本质是个单线程)，如下图所示：

        对于单线程下，我们不可避免程序中出现io操作，但如果我们能在自己的程序中(即用户程序级别，而非操作系统级别)控制单线程下的多个任务能在一个任务遇到io阻塞时就将寄存器上下文和栈保存到某个其他地方，然后切换到另外一个任务去计算。在任务切回来的时候，恢复先前保存的寄存器上下文和栈，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被cpu执行的状态。

        相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，io比较少，从而会更多的将cpu的执行权限分配给我们的线程（注意：线程是CPU控制的，而协程是程序自身控制的，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级) 

我们老说协程协程，那么协程到底如何实现呢？这里给出下面的案例进行讲解：

请编写一个程序，完成如下功能：

1）在主线程中，开启一个goroutine，该goroutine每隔1秒输出”hello golang“

2）在主线程中也每隔一秒输出”hello world”，输出10次后，退出程序

3）要求主线程和goroutine同时执行

package main
import (
	"fmt"
	"strconv"
	"time"
)
func test() {
	for i := 0; i < 10; i++ {
		fmt.Println("hello golang + " + strconv.Itoa(i))
		// 阻塞1秒
		time.Sleep(1 * time.Second)
	}
}

func main() { // 主线程
	go test() // 开启协程

	for i := 0; i < 10; i++ {
		fmt.Println("hello world + " + strconv.Itoa(i))
		// 阻塞1秒
		time.Sleep(1 * time.Second)
	}
}

开启协程之后，协程和主线程交替执行，效果如下：

主线程和协程执行流程：可以从下图所示看到：

主死协从： 在go语言中有如下概念，如果主线程退出了，则协程即使还没有执行完毕，也会退出，当然协程也可以在主线程没有退出前，就自己结束了，比如完成了自己的任务，这里我们对上面的代码进行一个简单的修改，让协程的任务量变大，如下：

当我们运行程序之后，即使协程没有执行完毕，其仍要跟随主程序的结束而结束：

启动多协程

相比于线程，协程的创建和销毁成本非常低，这里可以在同一时间启动多个协程，它们会并发执行，go运行时会自动调度协程，以便它们可以在多个操作系统线程上运行，协程之间通常通过通道进行通信，以避免共享状态导致的竞态条件。下面是一个简单的go代码示例：

package main
import (
	"fmt"
	"time"
)
func main() {
	// 匿名函数+外部变量 = 闭包
	for i := 0; i <= 5; i++ {
		// 启动协程，使用匿名函数直接调用匿名按时
		go func(n int) {
			fmt.Println(n)
		}(i)
	}
	time.Sleep(time.Second * 2)
}

最终实现的效果如下所示，由于它们都在并发地运行，所以输出的顺序可能是不确定的，如果你想要控制协程的执行顺序或等待它们完成，你可以使用通道或其他同步机制，这个后面再讲：

当然如果不想使用time.Sleep的方式的话，也可以采用下面的方式进行实现：

package main
import (
	"fmt"
	"sync"
)
var wg sync.WaitGroup // 只定义无需赋值
func main() {
	// 启动五个协程
	for i := 0; i < 5; i++ {
		wg.Add(1) // 计数器加一
		go func(n int) {
			fmt.Println(n)
			wg.Done() // 协程执行完成减1
		}(i)
	}
	// 主线程一直在阻塞，什么时候wg减为0就停止
	wg.Wait()
}

如果多个协程操作同一个数据的情况下，给出如下代码进行示例：

package main
import (
	"sync"
)
// 定义一个变量
var totalNum int
var wg sync.WaitGroup // 只定义无需赋值

func add() {
	defer wg.Done()
	for i := 0; i < 100000000; i++ {
		totalNum++
	}
}
func sub() {
	defer wg.Done()
	for i := 0; i < 100000000; i++ {
		totalNum--
	}
}

func main() {
	wg.Add(2)
	// 启动两个协程
	go add()
	go sub()
	// 等待协程结束
	wg.Wait()
	println(totalNum)
}

因为协程是交替不确定的执行，结果可能都不一样，如下图所示：

初识锁

从上文的案例可以看出，如果多个协程操作同一个数据， 因为协程会交替并发执行，所以会出现争抢资源的情况，导致最终的结果可能并不是我们想要的，那么我们如何处理这个问题呢？这里我们就需要通过一个机制，确保一个协程在执行逻辑的时候另外的协程不执行，这里我们就需要引入一个概念：“锁的机制”，即加入互斥锁，示例代码如下，最终结果为0，是我们想要的：

package main
import (
	"sync"
)
// 定义一个变量
var totalNum int
var wg sync.WaitGroup // 只定义无需赋值
// 加入互斥锁
var lock sync.Mutex

func add() {
	defer wg.Done()
	for i := 0; i < 100000000; i++ {
		lock.Lock() // 加锁
		totalNum++
		lock.Unlock() // 解锁
	}
}
func sub() {
	defer wg.Done()
	for i := 0; i < 100000000; i++ {
		lock.Lock() // 加锁
		totalNum--
		lock.Unlock() // 解锁
	}
}

func main() {
	wg.Add(2)
	// 启动两个协程
	go add()
	go sub()
	// 等待协程结束
	wg.Wait()
	println(totalNum)
}

当然golang中sync包实现了两种锁Mutex（互斥锁）和RWMutex（读写锁)，具体如下：

1）互斥锁：其中Mutex为互斥锁，Lock(加锁，Unlock()解锁，使用Lock()加锁后，便不能再次对其进行加锁，直到利用Unlock(解锁对其解锁后，才能再次加锁．适用于读写不确定场景，即读写次数没有明显的区别，其性能和效率相对较低。

2）读写锁：RWMutex是一个读写锁，其经常用于读次数远远多于写次数的场景，在读的时候数据之间不产生影响，写和读之间才会产生影响。

package main
import (
	"fmt"
	"sync"
	"time"
)
// 定义一个变量
var totalNum int
var wg sync.WaitGroup // 只定义无需赋值
// 加入读写锁
var lock sync.RWMutex

func read() {
	defer wg.Done()
	lock.RLock() // 读锁，如果只是读数据那么这个锁不产生任何影响，但是读写同时发生时，就会有影响
	fmt.Println("开始读取数据")
	time.Sleep(time.Second)
	fmt.Println("读取数据完毕")
	lock.RUnlock() // 关锁
}
func write() {
	defer wg.Done()
	lock.Lock() // 写锁
	fmt.Println("开始写入数据")
	time.Sleep(time.Second)
	fmt.Println("写入数据完毕")
	lock.Unlock() // 关锁
}

func main() {
	wg.Add(6)
	// 启动两个协程,读多写少
	for i := 0; i < 5; i++ {
		go read()
	}
	go write()
	// 等待协程结束
	wg.Wait()
}

初识管道

在go语言中，管道（Channel）是一种特殊的类型，用于在协程（goroutine）之间进行通信，它允许一个协程将数据发送到管道，并由另一个协程从管道中接收数据。这种机制可以实现协程之间的同步和数据交换，以下是管道相关特点介绍：

1）管道本质就是一个数据结构-队列

2）数据是先进先出

3）自身线程安全，多协程访问时，不需要加锁，channel本身就是线程安全的

4）管道有类型的，一个string的管道只能存放string类型数据

管道的定义： var 变量名chan 数据类型

chan是管道关键字；数据类型指的是管道的类型，里面放入数据的类型，管道是有类型的，intChan只能写入整数int；管道是引用类型，必须初始化才能写入数据，即make后才能使用。

package main

import "fmt"

func main() {
	// 定义一个int类型管道
	var intChan chan int
	// 通过make初始化，管道可以存放3个int类型数据
	intChan = make(chan int, 3)
	// 证明管道是引用类型
	fmt.Printf("intChan的值：%v 
", intChan) // intChan的值：0xc000018200
	// 向管道存放数据,注意存放的数据不能超出管道的容量
	intChan <- 1 // 往管道中存放数据
	num := 20
	intChan <- num // 往管道中存放数据

	// 取出管道数据（队列先进先出）
	fmt.Printf("intChan的值：%v 
", <-intChan) // intChan的值：1
	fmt.Printf("intChan的值：%v 
", <-intChan) // intChan的值：20

	// 输出管道的长度
	fmt.Printf("intChan的长度：%d 
", len(intChan)) // intChan的长度：2
}

管道的关闭：使用内置函数close可以关闭管道，当管道关闭后，就不能再向管道写数据了，但是仍然可以从该管道读取数据。

package main

import "fmt"

func main() {
	// 定义管道
	var intChan chan int
	// 通过make初始化管道，可以存放3个int类型数据
	intChan = make(chan int, 3)
	// 往管道中写入数据
	intChan <- 1
	intChan <- 2

	// 关闭管道
	close(intChan)

	// 再次写入数据会报错
	//intChan <- 3 // panic: send on closed channel

	// 当管道关闭后，再读取数据是可以的
	num := <-intChan
	fmt.Println(num) // 1
}

管道的遍历：管道支持for-range的方式进行遍历，请注意两个细节：

1）在遍历时，如果管道没有关闭，则会出现deadlock的错误

2）在遍历时，如果管道已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。

package main

import "fmt"

func main() {
	// 定义管道
	var intChan chan int
	// 通过make初始化管道，可以存放100个int类型数据
	intChan = make(chan int, 100)
	// 往管道中写入数据
	for i := 0; i < 100; i++ {
		intChan <- i
	}
	// 在遍历前，如果没有关闭管道，就会出现deedlock的错误
	// 遍历管道中的数据
	for v := range intChan {
		fmt.Println("value = ", v)
	}
}

如上代码由于没有关闭管道，导致出现如下问题：

所以我们需要在遍历管道前，需要进行管道的关闭，如下：

管道的只读只写： 可以在初始化管道的时候，通过代码设置只读只写属性，如下：

func main() { // 主线程
	// 默认情况下，管道是双向的，可读可写
	var intChan chan int
	// 声明为只写管道
	var intChan1 chan<- int
	// 声明为只读管道
	var intChan2 <-chan int
}

select功能：解决多个管道的选择问题，也可以叫做多路复用，可以从多个管道中随机公平地选择一个来执行，如下代码输出的就是hello

1）case后面必须进行的是io操作，不能是等值，随机去选择一个io操作

2）default防止select被阻塞住，加入default 

package main

import (
	"fmt"
	"time"
)

func main() { // 主线程
	// 定义一个int类型管道
	intChan := make(chan int, 1)
	go func() {
		time.Sleep(time.Second * 5)
		intChan <- 1
	}()
	// 定义一个string类型管道
	stringChan := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 2)
		stringChan <- "hello"
	}()
	//fmt.Println(<-intChan) // 阻塞等待，本身取数据就是阻塞的

	select {
	case v := <-intChan:
		fmt.Println("intChan: ", v)
	case v := <-stringChan:
		fmt.Println("stringChan: ", v)
	default:
		fmt.Println("防止select被阻塞")
	}
}

异常错误捕获：多个协程工作，其中一个协程出现panic，导致程序崩溃，这里利用refer+recover捕获panic进行处理，即使协程出现问题，主线程仍然不受影响可以继续执行，示例代码如下：

package main

import (
	"fmt"
	"time"
)

// 输出数字
func printNum() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

// 除法操作
func devide() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("程序异常退出")
		}
	}()
	num1 := 10
	num2 := 0
	result := num1 / num2
	fmt.Println(result)
}

func main() {
	// 启动两个协程
	go printNum()
	go devide()
	time.Sleep(time.Second * 5)
}

得到的结果如下所示：

协程与管道协同

接下来我们通过一个案例来实现协程与管道的共同操作，案例需求如下：

请完成协程和管道协同工作的案例，具体要求：

1）开启一个writeData协程，向管道中写入50个整数。

2）开启一个readData协程，从管道中读取writeData写入的数据。

3）注意：writeData和readDate操作的是同一个管道。

4）主线程需要等待writeData和readDate协程都完成工作才能退出

其对应的原理图如下所示：

package main

import (
	"fmt"
	"strconv"
	"sync"
	"time"
)

var wg sync.WaitGroup

// 写数据
func writeData(intChan chan int) {
	defer wg.Done()
	for i := 0; i < 50; i++ {
		intChan <- i
		fmt.Println("写入的数据为：" + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
	// 关闭通道
	close(intChan)
}

// 读数据
func readData(intChan chan int) {
	defer wg.Done()
	for i := range intChan {
		fmt.Println("读取的数据为：" + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}
func main() { // 主线程
	// 写协程和读协程共同操作同一个通道
	intChan := make(chan int, 50)
	wg.Add(2)
	// 开启读和写的协程
	go writeData(intChan)
	go readData(intChan)
	// 主线程一直在阻塞，什么时候wg.Done()减为0，主线程才会结束
	wg.Wait()
}

最终实现的效果如下所示：