感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7058.html
引言
Goroutine 和 Channel 是 Go 语言并发编程的两大基石。Goroutine 用于执行并发任务，Channel 用于 goroutine 之间的同步、通信。
在Golang的并发哲学里，有一句非常著名的话：
Do not communicate by sharing memory; instead, share memory by communicating.
意思是：不要通过共享内存来通信，而要通过通信来实现内存共享，它依赖CSP（Communication Sequence Process） 模型，简称通信顺序进程。
Go提倡使用通信的方法代替共享内存，当一个Goroutine需要和其他Goroutine资源共享时，Channel就会在他们之间架起一座桥梁，并提供确保安全同步的机制。
Channel本质上还是一个队列，遵循FIFO（First In-First Out）原则，
创建通道
创建通道需要用到关键字 make ，格式如下：
通道实例 := make(chan 数据类型)
- 数据类型：通道内传输的元素类型。
- 通道实例：通过make创建的通道句柄。
使用通道
通道创建后，就可以使用通道进行发送和接收操作。
写入
通道的写入使用特殊的操作符<-，将数据通过通道发送的格式为：
通道变量 <- 值
（可以简单理解为箭头方向为传递的值最终去向）
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
读取
通道的读取同样使用<-操作符，通道接收有如下特性：
- 通道的收发操作在不同的两个 goroutine 间进行。
- 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个 goroutine 中进行。
- 接收将持续阻塞直到发送方发送数据。
通道的数据接收一共有以下 4 种写法:
- 阻塞式接收
阻塞模式接收数据时，接收值只有一个，格式如下：
data := <-ch
执行该语句时程序将会阻塞，直到接收到数据并赋值给 data 变量。
- 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
特点：非阻塞的通道接收方法可能造成高的 CPU 占用，不建议这么使用。
- 忽略接收的数据
忽略从通道返回的任何数据，格式如下：
<-ch
特点：该方法也是阻塞的，必须等到通道返回了程序才会继续往下走。
- 循环接收
通道的数据接收可以借用 for range 语句进行多个元素的接收操作，格式如下：
for data := range ch {
// do sth.
}
通道 ch 是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过 for 遍历获得的变量只有一个，即上面例子中的 data。
只读/只写通道
一般来说，通道都是双向的，即数据可以进入和输出。但是，为了符合某些特殊业务场景，官方还提供了只支持读（Read Only）或只支持写（Write Only）的通道，格式如下：
//定义只读通道
ch_r := <-chan interface{}
//定义只写通道
ch_w := <-chan interface{}
有缓冲通道
Go语言中有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。
有缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型, 缓冲大小)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：决定通道最多可以保存的元素数量。
- 通道实例：被创建出的通道实例。
下面我借用以下的图片来说明下这个通道原理
- 左边的goroutine不断的往通道中塞数据
- 右边的goroutine不断的从通道中拿数据
- 一个读/一个写，同步作业
- 左边的goroutine全部数据已经放完了，但此时通道中还剩余数据，所有右边的goroutine还在工作
无缓冲通道
Go语言中无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。
无缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：0
- 通道实例：被创建出的通道实例。
为了讲得更清楚一些，我也找了一张额外的图来说明：
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。在第 4 步和第 5 步，进行交换，并最终在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
总结
GoLang的通道是支撑并发系统稳定高效运行的重要工具，只有充分了解了它，才能在业务开发和问题排查中找到最关键的方案。知己知彼，百战不殆。感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7058/
引言
Goroutine 和 Channel 是 Go 语言并发编程的两大基石。Goroutine 用于执行并发任务，Channel 用于 goroutine 之间的同步、通信。
在Golang的并发哲学里，有一句非常著名的话：
Do not communicate by sharing memory; instead, share memory by communicating.
意思是：不要通过共享内存来通信，而要通过通信来实现内存共享，它依赖CSP（Communication Sequence Process） 模型，简称通信顺序进程。
Go提倡使用通信的方法代替共享内存，当一个Goroutine需要和其他Goroutine资源共享时，Channel就会在他们之间架起一座桥梁，并提供确保安全同步的机制。
Channel本质上还是一个队列，遵循FIFO（First In-First Out）原则，
创建通道
创建通道需要用到关键字 make ，格式如下：
通道实例 := make(chan 数据类型)
- 数据类型：通道内传输的元素类型。
- 通道实例：通过make创建的通道句柄。
使用通道
通道创建后，就可以使用通道进行发送和接收操作。
写入
通道的写入使用特殊的操作符<-，将数据通过通道发送的格式为：
通道变量 <- 值
（可以简单理解为箭头方向为传递的值最终去向）
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
读取
通道的读取同样使用<-操作符，通道接收有如下特性：
- 通道的收发操作在不同的两个 goroutine 间进行。
- 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个 goroutine 中进行。
- 接收将持续阻塞直到发送方发送数据。
通道的数据接收一共有以下 4 种写法:
- 阻塞式接收
阻塞模式接收数据时，接收值只有一个，格式如下：
data := <-ch
执行该语句时程序将会阻塞，直到接收到数据并赋值给 data 变量。
- 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
特点：非阻塞的通道接收方法可能造成高的 CPU 占用，不建议这么使用。
- 忽略接收的数据
忽略从通道返回的任何数据，格式如下：
<-ch
特点：该方法也是阻塞的，必须等到通道返回了程序才会继续往下走。
- 循环接收
通道的数据接收可以借用 for range 语句进行多个元素的接收操作，格式如下：
for data := range ch {
// do sth.
}
通道 ch 是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过 for 遍历获得的变量只有一个，即上面例子中的 data。
只读/只写通道
一般来说，通道都是双向的，即数据可以进入和输出。但是，为了符合某些特殊业务场景，官方还提供了只支持读（Read Only）或只支持写（Write Only）的通道，格式如下：
//定义只读通道
ch_r := <-chan interface{}
//定义只写通道
ch_w := <-chan interface{}
有缓冲通道
Go语言中有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。
有缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型, 缓冲大小)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：决定通道最多可以保存的元素数量。
- 通道实例：被创建出的通道实例。
下面我借用以下的图片来说明下这个通道原理
- 左边的goroutine不断的往通道中塞数据
- 右边的goroutine不断的从通道中拿数据
- 一个读/一个写，同步作业
- 左边的goroutine全部数据已经放完了，但此时通道中还剩余数据，所有右边的goroutine还在工作
无缓冲通道
Go语言中无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。
无缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：0
- 通道实例：被创建出的通道实例。
为了讲得更清楚一些，我也找了一张额外的图来说明：
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。在第 4 步和第 5 步，进行交换，并最终在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
总结
GoLang的通道是支撑并发系统稳定高效运行的重要工具，只有充分了解了它，才能在业务开发和问题排查中找到最关键的方案。知己知彼，百战不殆。感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7058/
引言
Goroutine 和 Channel 是 Go 语言并发编程的两大基石。Goroutine 用于执行并发任务，Channel 用于 goroutine 之间的同步、通信。
在Golang的并发哲学里，有一句非常著名的话：
Do not communicate by sharing memory; instead, share memory by communicating.
意思是：不要通过共享内存来通信，而要通过通信来实现内存共享，它依赖CSP（Communication Sequence Process） 模型，简称通信顺序进程。
Go提倡使用通信的方法代替共享内存，当一个Goroutine需要和其他Goroutine资源共享时，Channel就会在他们之间架起一座桥梁，并提供确保安全同步的机制。
Channel本质上还是一个队列，遵循FIFO（First In-First Out）原则，
创建通道
创建通道需要用到关键字 make ，格式如下：
通道实例 := make(chan 数据类型)
- 数据类型：通道内传输的元素类型。
- 通道实例：通过make创建的通道句柄。
使用通道
通道创建后，就可以使用通道进行发送和接收操作。
写入
通道的写入使用特殊的操作符<-，将数据通过通道发送的格式为：
通道变量 <- 值
（可以简单理解为箭头方向为传递的值最终去向）
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
读取
通道的读取同样使用<-操作符，通道接收有如下特性：
- 通道的收发操作在不同的两个 goroutine 间进行。
- 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个 goroutine 中进行。
- 接收将持续阻塞直到发送方发送数据。
通道的数据接收一共有以下 4 种写法:
- 阻塞式接收
阻塞模式接收数据时，接收值只有一个，格式如下：
data := <-ch
执行该语句时程序将会阻塞，直到接收到数据并赋值给 data 变量。
- 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
特点：非阻塞的通道接收方法可能造成高的 CPU 占用，不建议这么使用。
- 忽略接收的数据
忽略从通道返回的任何数据，格式如下：
<-ch
特点：该方法也是阻塞的，必须等到通道返回了程序才会继续往下走。
- 循环接收
通道的数据接收可以借用 for range 语句进行多个元素的接收操作，格式如下：
for data := range ch {
// do sth.
}
通道 ch 是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过 for 遍历获得的变量只有一个，即上面例子中的 data。
只读/只写通道
一般来说，通道都是双向的，即数据可以进入和输出。但是，为了符合某些特殊业务场景，官方还提供了只支持读（Read Only）或只支持写（Write Only）的通道，格式如下：
//定义只读通道
ch_r := <-chan interface{}
//定义只写通道
ch_w := <-chan interface{}
有缓冲通道
Go语言中有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。
有缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型, 缓冲大小)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：决定通道最多可以保存的元素数量。
- 通道实例：被创建出的通道实例。
下面我借用以下的图片来说明下这个通道原理
- 左边的goroutine不断的往通道中塞数据
- 右边的goroutine不断的从通道中拿数据
- 一个读/一个写，同步作业
- 左边的goroutine全部数据已经放完了，但此时通道中还剩余数据，所有右边的goroutine还在工作
无缓冲通道
Go语言中无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。
无缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：0
- 通道实例：被创建出的通道实例。
为了讲得更清楚一些，我也找了一张额外的图来说明：
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。在第 4 步和第 5 步，进行交换，并最终在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
总结
GoLang的通道是支撑并发系统稳定高效运行的重要工具，只有充分了解了它，才能在业务开发和问题排查中找到最关键的方案。知己知彼，百战不殆。感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7058/
引言
Goroutine 和 Channel 是 Go 语言并发编程的两大基石。Goroutine 用于执行并发任务，Channel 用于 goroutine 之间的同步、通信。
在Golang的并发哲学里，有一句非常著名的话：
Do not communicate by sharing memory; instead, share memory by communicating.
意思是：不要通过共享内存来通信，而要通过通信来实现内存共享，它依赖CSP（Communication Sequence Process） 模型，简称通信顺序进程。
Go提倡使用通信的方法代替共享内存，当一个Goroutine需要和其他Goroutine资源共享时，Channel就会在他们之间架起一座桥梁，并提供确保安全同步的机制。
Channel本质上还是一个队列，遵循FIFO（First In-First Out）原则，
创建通道
创建通道需要用到关键字 make ，格式如下：
通道实例 := make(chan 数据类型)
- 数据类型：通道内传输的元素类型。
- 通道实例：通过make创建的通道句柄。
使用通道
通道创建后，就可以使用通道进行发送和接收操作。
写入
通道的写入使用特殊的操作符<-，将数据通过通道发送的格式为：
通道变量 <- 值
（可以简单理解为箭头方向为传递的值最终去向）
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
读取
通道的读取同样使用<-操作符，通道接收有如下特性：
- 通道的收发操作在不同的两个 goroutine 间进行。
- 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个 goroutine 中进行。
- 接收将持续阻塞直到发送方发送数据。
通道的数据接收一共有以下 4 种写法:
- 阻塞式接收
阻塞模式接收数据时，接收值只有一个，格式如下：
data := <-ch
执行该语句时程序将会阻塞，直到接收到数据并赋值给 data 变量。
- 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
特点：非阻塞的通道接收方法可能造成高的 CPU 占用，不建议这么使用。
- 忽略接收的数据
忽略从通道返回的任何数据，格式如下：
<-ch
特点：该方法也是阻塞的，必须等到通道返回了程序才会继续往下走。
- 循环接收
通道的数据接收可以借用 for range 语句进行多个元素的接收操作，格式如下：
for data := range ch {
// do sth.
}
通道 ch 是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过 for 遍历获得的变量只有一个，即上面例子中的 data。
只读/只写通道
一般来说，通道都是双向的，即数据可以进入和输出。但是，为了符合某些特殊业务场景，官方还提供了只支持读（Read Only）或只支持写（Write Only）的通道，格式如下：
//定义只读通道
ch_r := <-chan interface{}
//定义只写通道
ch_w := <-chan interface{}
有缓冲通道
Go语言中有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。
有缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型, 缓冲大小)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：决定通道最多可以保存的元素数量。
- 通道实例：被创建出的通道实例。
下面我借用以下的图片来说明下这个通道原理
- 左边的goroutine不断的往通道中塞数据
- 右边的goroutine不断的从通道中拿数据
- 一个读/一个写，同步作业
- 左边的goroutine全部数据已经放完了，但此时通道中还剩余数据，所有右边的goroutine还在工作
无缓冲通道
Go语言中无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。
无缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：0
- 通道实例：被创建出的通道实例。
为了讲得更清楚一些，我也找了一张额外的图来说明：
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。在第 4 步和第 5 步，进行交换，并最终在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
总结
GoLang的通道是支撑并发系统稳定高效运行的重要工具，只有充分了解了它，才能在业务开发和问题排查中找到最关键的方案。知己知彼，百战不殆。感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7058/
引言
Goroutine 和 Channel 是 Go 语言并发编程的两大基石。Goroutine 用于执行并发任务，Channel 用于 goroutine 之间的同步、通信。
在Golang的并发哲学里，有一句非常著名的话：
Do not communicate by sharing memory; instead, share memory by communicating.
意思是：不要通过共享内存来通信，而要通过通信来实现内存共享，它依赖CSP（Communication Sequence Process） 模型，简称通信顺序进程。
Go提倡使用通信的方法代替共享内存，当一个Goroutine需要和其他Goroutine资源共享时，Channel就会在他们之间架起一座桥梁，并提供确保安全同步的机制。
Channel本质上还是一个队列，遵循FIFO（First In-First Out）原则，
创建通道
创建通道需要用到关键字 make ，格式如下：
通道实例 := make(chan 数据类型)
- 数据类型：通道内传输的元素类型。
- 通道实例：通过make创建的通道句柄。
使用通道
通道创建后，就可以使用通道进行发送和接收操作。
写入
通道的写入使用特殊的操作符<-，将数据通过通道发送的格式为：
通道变量 <- 值
（可以简单理解为箭头方向为传递的值最终去向）
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
读取
通道的读取同样使用<-操作符，通道接收有如下特性：
- 通道的收发操作在不同的两个 goroutine 间进行。
- 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个 goroutine 中进行。
- 接收将持续阻塞直到发送方发送数据。
通道的数据接收一共有以下 4 种写法:
- 阻塞式接收
阻塞模式接收数据时，接收值只有一个，格式如下：
data := <-ch
执行该语句时程序将会阻塞，直到接收到数据并赋值给 data 变量。
- 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
特点：非阻塞的通道接收方法可能造成高的 CPU 占用，不建议这么使用。
- 忽略接收的数据
忽略从通道返回的任何数据，格式如下：
<-ch
特点：该方法也是阻塞的，必须等到通道返回了程序才会继续往下走。
- 循环接收
通道的数据接收可以借用 for range 语句进行多个元素的接收操作，格式如下：
for data := range ch {
// do sth.
}
通道 ch 是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过 for 遍历获得的变量只有一个，即上面例子中的 data。
只读/只写通道
一般来说，通道都是双向的，即数据可以进入和输出。但是，为了符合某些特殊业务场景，官方还提供了只支持读（Read Only）或只支持写（Write Only）的通道，格式如下：
//定义只读通道
ch_r := <-chan interface{}
//定义只写通道
ch_w := <-chan interface{}
有缓冲通道
Go语言中有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。
有缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型, 缓冲大小)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：决定通道最多可以保存的元素数量。
- 通道实例：被创建出的通道实例。
下面我借用以下的图片来说明下这个通道原理
- 左边的goroutine不断的往通道中塞数据
- 右边的goroutine不断的从通道中拿数据
- 一个读/一个写，同步作业
- 左边的goroutine全部数据已经放完了，但此时通道中还剩余数据，所有右边的goroutine还在工作
无缓冲通道
Go语言中无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。
无缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：0
- 通道实例：被创建出的通道实例。
为了讲得更清楚一些，我也找了一张额外的图来说明：
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。在第 4 步和第 5 步，进行交换，并最终在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
总结
GoLang的通道是支撑并发系统稳定高效运行的重要工具，只有充分了解了它，才能在业务开发和问题排查中找到最关键的方案。知己知彼，百战不殆。感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7058/
引言
Goroutine 和 Channel 是 Go 语言并发编程的两大基石。Goroutine 用于执行并发任务，Channel 用于 goroutine 之间的同步、通信。
在Golang的并发哲学里，有一句非常著名的话：
Do not communicate by sharing memory; instead, share memory by communicating.
意思是：不要通过共享内存来通信，而要通过通信来实现内存共享，它依赖CSP（Communication Sequence Process） 模型，简称通信顺序进程。
Go提倡使用通信的方法代替共享内存，当一个Goroutine需要和其他Goroutine资源共享时，Channel就会在他们之间架起一座桥梁，并提供确保安全同步的机制。
Channel本质上还是一个队列，遵循FIFO（First In-First Out）原则，
创建通道
创建通道需要用到关键字 make ，格式如下：
通道实例 := make(chan 数据类型)
- 数据类型：通道内传输的元素类型。
- 通道实例：通过make创建的通道句柄。
使用通道
通道创建后，就可以使用通道进行发送和接收操作。
写入
通道的写入使用特殊的操作符<-，将数据通过通道发送的格式为：
通道变量 <- 值
（可以简单理解为箭头方向为传递的值最终去向）
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
读取
通道的读取同样使用<-操作符，通道接收有如下特性：
- 通道的收发操作在不同的两个 goroutine 间进行。
- 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个 goroutine 中进行。
- 接收将持续阻塞直到发送方发送数据。
通道的数据接收一共有以下 4 种写法:
- 阻塞式接收
阻塞模式接收数据时，接收值只有一个，格式如下：
data := <-ch
执行该语句时程序将会阻塞，直到接收到数据并赋值给 data 变量。
- 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
特点：非阻塞的通道接收方法可能造成高的 CPU 占用，不建议这么使用。
- 忽略接收的数据
忽略从通道返回的任何数据，格式如下：
<-ch
特点：该方法也是阻塞的，必须等到通道返回了程序才会继续往下走。
- 循环接收
通道的数据接收可以借用 for range 语句进行多个元素的接收操作，格式如下：
for data := range ch {
// do sth.
}
通道 ch 是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过 for 遍历获得的变量只有一个，即上面例子中的 data。
只读/只写通道
一般来说，通道都是双向的，即数据可以进入和输出。但是，为了符合某些特殊业务场景，官方还提供了只支持读（Read Only）或只支持写（Write Only）的通道，格式如下：
//定义只读通道
ch_r := <-chan interface{}
//定义只写通道
ch_w := <-chan interface{}
有缓冲通道
Go语言中有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。
有缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型, 缓冲大小)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：决定通道最多可以保存的元素数量。
- 通道实例：被创建出的通道实例。
下面我借用以下的图片来说明下这个通道原理
- 左边的goroutine不断的往通道中塞数据
- 右边的goroutine不断的从通道中拿数据
- 一个读/一个写，同步作业
- 左边的goroutine全部数据已经放完了，但此时通道中还剩余数据，所有右边的goroutine还在工作
无缓冲通道
Go语言中无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。
无缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：0
- 通道实例：被创建出的通道实例。
为了讲得更清楚一些，我也找了一张额外的图来说明：
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。在第 4 步和第 5 步，进行交换，并最终在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
总结
GoLang的通道是支撑并发系统稳定高效运行的重要工具，只有充分了解了它，才能在业务开发和问题排查中找到最关键的方案。知己知彼，百战不殆。感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7058/
引言
Goroutine 和 Channel 是 Go 语言并发编程的两大基石。Goroutine 用于执行并发任务，Channel 用于 goroutine 之间的同步、通信。
在Golang的并发哲学里，有一句非常著名的话：
Do not communicate by sharing memory; instead, share memory by communicating.
意思是：不要通过共享内存来通信，而要通过通信来实现内存共享，它依赖CSP（Communication Sequence Process） 模型，简称通信顺序进程。
Go提倡使用通信的方法代替共享内存，当一个Goroutine需要和其他Goroutine资源共享时，Channel就会在他们之间架起一座桥梁，并提供确保安全同步的机制。
Channel本质上还是一个队列，遵循FIFO（First In-First Out）原则，
创建通道
创建通道需要用到关键字 make ，格式如下：
通道实例 := make(chan 数据类型)
- 数据类型：通道内传输的元素类型。
- 通道实例：通过make创建的通道句柄。
使用通道
通道创建后，就可以使用通道进行发送和接收操作。
写入
通道的写入使用特殊的操作符<-，将数据通过通道发送的格式为：
通道变量 <- 值
（可以简单理解为箭头方向为传递的值最终去向）
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
读取
通道的读取同样使用<-操作符，通道接收有如下特性：
- 通道的收发操作在不同的两个 goroutine 间进行。
- 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个 goroutine 中进行。
- 接收将持续阻塞直到发送方发送数据。
通道的数据接收一共有以下 4 种写法:
- 阻塞式接收
阻塞模式接收数据时，接收值只有一个，格式如下：
data := <-ch
执行该语句时程序将会阻塞，直到接收到数据并赋值给 data 变量。
- 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
特点：非阻塞的通道接收方法可能造成高的 CPU 占用，不建议这么使用。
- 忽略接收的数据
忽略从通道返回的任何数据，格式如下：
<-ch
特点：该方法也是阻塞的，必须等到通道返回了程序才会继续往下走。
- 循环接收
通道的数据接收可以借用 for range 语句进行多个元素的接收操作，格式如下：
for data := range ch {
// do sth.
}
通道 ch 是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过 for 遍历获得的变量只有一个，即上面例子中的 data。
只读/只写通道
一般来说，通道都是双向的，即数据可以进入和输出。但是，为了符合某些特殊业务场景，官方还提供了只支持读（Read Only）或只支持写（Write Only）的通道，格式如下：
//定义只读通道
ch_r := <-chan interface{}
//定义只写通道
ch_w := <-chan interface{}
有缓冲通道
Go语言中有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。
有缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型, 缓冲大小)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：决定通道最多可以保存的元素数量。
- 通道实例：被创建出的通道实例。
下面我借用以下的图片来说明下这个通道原理
- 左边的goroutine不断的往通道中塞数据
- 右边的goroutine不断的从通道中拿数据
- 一个读/一个写，同步作业
- 左边的goroutine全部数据已经放完了，但此时通道中还剩余数据，所有右边的goroutine还在工作
无缓冲通道
Go语言中无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。
无缓冲通道的定义方式如下：
通道实例 := make(chan 通道类型)
- 通道类型：和无缓冲通道用法一致，影响通道发送和接收的数据类型。
- 缓冲大小：0
- 通道实例：被创建出的通道实例。
为了讲得更清楚一些，我也找了一张额外的图来说明：
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。在第 4 步和第 5 步，进行交换，并最终在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
总结
GoLang的通道是支撑并发系统稳定高效运行的重要工具，只有充分了解了它，才能在业务开发和问题排查中找到最关键的方案。知己知彼，百战不殆。