Golang并发模型：Goroutine 与 Channel 初探

goroutine

goroutine 是 Go 语言中的一种轻量级线程（lightweight thread），由 Go 运行时环境管理。与传统的线程相比，goroutine 的创建和销毁的开销很小，可以轻松创建成千上万个 goroutine，而不会导致系统性能下降。

以下是一些关于 goroutine 的重要特性：

1. 轻量级： 每个 goroutine 的栈大小初始时只有几 KB，可以根据需要进行动态扩展和收缩。

2. 并发执行： Go 语言通过 goroutine 实现并发编程，允许在程序中同时执行多个任务。通过 goroutine，可以更方便地编写并发程序。

3. 独立调度： Go 运行时具有自己的调度器，它负责在多个 goroutine 之间进行协作式调度。与操作系统线程不同，goroutine 的调度是在用户空间进行的，减少了上下文切换的成本。

4. 通信通过通道： 多个 goroutine 之间通过通道进行通信。通道是一种数据结构，用于在 goroutine 之间传递数据。通过使用通道，可以更安全、更简单地实现 goroutine 之间的通信和同步。

以下是一个简单的示例，演示了如何创建和运行一个 goroutine：

package main

import (
	"fmt"
	"time"
)

// 子goroutine
func newTask() {
	for i := 0; ; i++ {
		fmt.Printf("new goroutine:i = %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

// 主goroutine
func main() {
	// 创建一个go程 去执行newTask()流程
	go newTask()
	
	for i := 0; ; i++ {
		fmt.Printf("main goroutine:i = %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

由运行结果可以看出，newTask 函数被启动为一个 goroutine，与主 goroutine 同时执行。由于 goroutine 是并发执行的，输出将交替显示两个 goroutine 的执行结果。

但是，当主goroutine执行任务完成退出比子goroutine早时，程序就会直接终止，而不再等待其他的 goroutine 执行完毕。如以下代码所示。

package main

import (
	"fmt"
	"time"
)

// 子goroutine
func newTask() {
	for i := 0; ; i++ {
		fmt.Printf("new goroutine:i = %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

// 主goroutine
func main() {
	// 创建一个go程 去执行newTask()流程
	go newTask()

	fmt.Println("main goroutine exit")
}
/*输出结果
main goroutine exit
*/

goexit()

runtime.Goexit() 是 Go 语言 runtime 包提供的一个函数，用于立即终止当前 goroutine 的执行。调用 Goexit 会导致当前 goroutine 进行善后工作（执行已注册的 defer 语句）并返回，而不会影响其他正在运行的 goroutine。

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	// 用go创建一个形参为空，返回值为空的函数
	go func() {
		defer fmt.Println("A.defer")

		func() {
			defer fmt.Println("B.defer")

			runtime.Goexit()
			fmt.Println("B")
		}()

		fmt.Println("A")
	}()

	for {
		time.Sleep(1 * time.Second)
	}
}
/*输出结果
B.defer
A.defer
*/

在 goroutine 内部的第二个 defer 语句 defer fmt.Println("B.defer") 表示在该 goroutine 返回之前执行。然后，在这个 goroutine 内部的匿名函数中调用了 runtime.goexit()，这会立即结束当前 goroutine 的执行。

由于 runtime.goexit()的调用，后面的代码不再执行，包括 “B” 的打印语句和 “A” 的打印语句。

channel

在Go语言中，channel 是一种用于在 goroutine 之间进行通信和同步的数据结构。它提供了一种安全、简单且高效的方式，使得不同的 goroutine 之间能够传递数据和同步操作。

channel的定义：c := make(chan int)。

下面是进行 goroutine 间通信的基本例子。因为 channel 是阻塞的，所以在主 goroutine 中接收数据的操作 num := <-c 会等待直到 goroutine 发送完数据为止。

package main

import "fmt"

func main() {
	c := make(chan int)

	go func() {
		defer fmt.Println("goroutine end")

		fmt.Println("goroutine正在运行")

		c <- 666 //将666发送给c
	}()

	num := <-c //从c中接收数据，并赋值给num

	fmt.Println("num =", num)
	fmt.Println("main goroutine end")
}
/*输出结果
goroutine正在运行
goroutine end
num = 666
main goroutine end
*/

缓冲

上面例子中的channel是一个无缓冲的，其运行的具体过程如下图所示。

在给channel加上缓冲后，运行过程如下图。

下面这段代码演示了使用带有缓冲的 channel 进行 goroutine 间通信的例子。由于通道带有缓冲，即使没有立即被接收，子 goroutine 依然可以向通道发送多个数据，直到达到缓冲容量。在主 goroutine 中，使用缓冲通道可以使得发送和接收操作更灵活，不需要等待另一方立即接收。

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int, 3) // 带有缓冲的channel

	fmt.Println("len(c) =", len(c), "cap(c) =", cap(c))

	go func() {
		defer fmt.Println("子go程结束")

		for i := 0; i < 3; i++ {
			c <- i
			fmt.Println("子go程正在运行，len(c) =", len(c), "cap(c) =", cap(c))
		}
	}()

	time.Sleep(2 * time.Second)

	for i := 0; i < 3; i++ {
		num := <-c
		fmt.Println("num =", num)
	}

	fmt.Println("主go程结束")
}
/*运行结果
len(c) = 0 cap(c) = 3
子go程正在运行，len(c) = 1 cap(c) = 3
子go程正在运行，len(c) = 2 cap(c) = 3
子go程正在运行，len(c) = 3 cap(c) = 3
子go程正在运行，len(c) = 3 cap(c) = 3
子go程结束
num = 0
num = 1
num = 2
num = 3
主go程结束
*/

close

close 函数用于关闭一个通道。

package main

import "fmt"

func main() {
	c := make(chan int)

	go func() {
		for i := 0; i < 3; i++ {
			c <- i
		}
		close(c) // close可以关闭一个channel
	}()

	for {
		// ok如果为true表示channel没有关闭，如果为false表示已经关闭
		if data, ok := <-c; ok {
			fmt.Println(data)
		} else {
			break
		}
	}
	fmt.Println("main goroutine end")
}

channel无需像文件一样经常关闭，只有确实不需要发数据了，或者想显式结束range循环，才去关闭channel。
关闭channel后，无法再向channel发送数据，但是可以继续接收数据。
对于nil channel，无论收发都会被阻塞。

range

当使用 range 迭代通道时，它会一直阻塞，直到通道关闭且所有的元素都被读取完毕。需要注意的是，在使用 range 迭代通道时，通道必须在某个地方被关闭，否则 range 不会结束。否则，它会一直等待新的数据，导致程序阻塞。

package main

import "fmt"

func main() {
	c := make(chan int)

	go func() {
		for i := 0; i < 3; i++ {
			c <- i
		}
		close(c) // close可以关闭一个channel
	}()

	// 可以使用range来迭代不断操作channel
	for data := range c {
		fmt.Println(data)
	}
	fmt.Println("main goroutine end")
}

select

单流程下一个go只能监控一个channel的状态，select可以完成监控多个channel

基本语法：

select {
case <- chan1:
	// 如果chan1成功读取到数据，就会进入该case并处理
case chan2 <- 1:
	// 如果成功向chan2写入数据，就会进入该case并处理
default:
	// 如果上面都没有成功，就进入default处理
}

下面是一个通过 Go 语言的 select 语句和通道（channel）来生成斐波那契数列的例子。

package main

import "fmt"

func fibonacii(c, quit chan int) {
	x, y := 1, 1
	for {
		select {
		case c <- x:
			// 如果c可写，那么就会进入该case
			x = y
			y = x + y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)

	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()

	fibonacii(c, quit)
}

这个程序的输出是斐波那契数列的前 10 个数字，然后输出 “quit”。由于 main 函数中的 goroutine 先执行，因此在 quit 通道被关闭之前，fibonacci 函数中的循环会一直运行。