客服电话
APP下载
迪恩网络APP
随时随地掌握行业动态
官方微信
扫描二维码
关注迪恩网络微信公众号
|
简而言之，所谓并发编程是指在一台处理器上"同时"处理多个任务。 通常程序会被编写为一个顺序执行并完成一个独立任务的代码。如果没有特别的需求，最好总是这样写代码，因为这种类型的程序通常很容易写，也很容易维护。不过也有一些情况下，并行执行多个任务会有更大的好处。一个例子是，Web服务器需要在各自独立的套接字(socket)上同时接受多个数据请求。每个套接字的请求都是独立的，可以完全独立于其他套接字进行处理。具有并行执行多个请求的能力可以显著提高这类系统的性能。考虑到这一点，Go语言的语法和运行时直接内置了对并发的支持。 宏观的并发是指在一段时间内，有多个程序在同时运行。 并发在微观上，是指在同一时刻只能有一条指令执行，但多个程序指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个程序快速交替的执行。
1.1 并行和并发并行：指在同一时刻，有多条指令在多个处理器上同时执行。 并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，通过cpu时间片轮转使多个进程快速交替的执行。 并发(concurrency)不是并行(parallelism)。并行是让不同的代码片段同时在不同的物理处理器上执行。并行的关键是同时做很多事情，而并发是指同时管理很多事情，这些事情可能只做了一半就被暂停去做别的事情了。在很多情况下，并发的效果比并行好，因为操作系统和硬件的总资源一半很少，但能支持系统同时做很多事情。这种"使用较少资源做更多的事情"的哲学，也是指导Go语言设计的哲学。
二.常见的并发编程基础2.1 进程并发(1)程序与进程 程序：是指编译好的二进制文件，在磁盘上，不占用系统资源(内存、打开的文件、设备、锁....)，是一个静态的实体。 进程：是指一个程序在运行时所需要和维护的资源的集合，是一个动态的实体。 进程和程序并不是一一对应的，一个程序执行在不同的数据集上就成为不同的进程，可以用进程控制块(PCB)来唯一地标识每个进程。而这一点正是程序无法做到的，由于程序没有和数据产生直接的联系，既使是执行不同的数据的程序，他们的指令的集合依然是一样的，所以无法唯一地标识出这些运行于不同数据集上的程序。一般来说，一个进程肯定有一个与之对应的程序，而且只有一个。而一个程序有可能没有与之对应的进程(因为它没有执行),也有可能有多个进程与之对应(运行在几个不同的数据集上)。
(2)进程地址空间 地址空间就是每个进程所能访问的内存地址范围。 这个地址范围不是真实的，是虚拟地址的范围，有时甚至会超过实际物理内存的大小。 现代的操作系统中进程都是在保护模式下运行的，地址空间其实是操作系统给进程用的一段连续的虚拟内存空间。 地址空间最终会通过虚拟内训映射管理单元映射到物理内存上，因为内核操作的是物理内存。 虽然地址空间的范围很大，但是进程也不一定有权限访问全部的地址空间(一般都是只能访问地址空间中的一些地址区间)， 进程能够访问的那些地址区间也称为 内存区域。 进程如果访问了有效内存区域以外的内容就会报 “段错误” 信息。
代码段：程序代码在内存中的映射，存放函数体的二进制代码。 初始化过的数据(Data):在程序运行初已经对变量进行初始化的数据。 未初始化过的数据(BSS):在程序运行初未对变量进行初始化的数据。 栈 (Stack):存储局部、临时变量，函数调用时，存储函数的返回指针，用于控制函数的调用和返回。在程序块开始时自动分配内存,结束时自动释放内存，其操作方式类似于数据结构中的栈。 堆 (Heap):存储动态内存分配,需要程序员手工分配,手工释放.注意它与数据结构中的堆是两回事，分配方式类似于链表。
每个进程都有自己的地址空间。对32位进程来说，由于32位指针可以表示从0x00000000到0xFFFFFFFF之间的任一值，地址空间的大小为4GB。对64位进程来说，由于64位指针可以表示从0x00000000'00000000到0xFFFFFFFF'FFFFFFFF之间的任一值， 地址空间大小为16GB。其实这个地址空间是不存在的，也就是我们所说的进程虚拟内存空间。
(3)进程的状态 进程基本的状态有5种。分别为初始态，就绪态，运行态，挂起态与终止态。其中初始态为进程准备阶段，常与就绪态结合来看。
(4)进程并发 在使用进程实现并发时会出现什么问题呢？ 1：系统开销比较大，占用资源比较多，开启进程数量比较少。 2：在unix/linux系统下，还会产生"孤儿进程"和"僵尸进程"。 在操作系统运行过程中，可以产生很多的进程。在unix/linux系统中，正常情况下，子进程是通过父进程fork创建的，子进程再创建新的进程。并且父进程永远无法预测子进程到底什么时候结束。当一个进程完成它的工作终止之后，它的父进程需要调用系统调用取得子进程的终止状态。 孤儿进程： 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。 僵尸进程： 子进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。 守护进程： 永久运行在系统中，不占用控制终端。不与前台用户进行交互。通常采用以d结尾命名方法
2.2 线程并发LWP：light weight process 轻量级的进程，本质仍是进程(Linux下)。 进程：独立地址空间，拥有PCB 线程：有独立的PCB，但没有独立的地址空间(共享) 区别：在于是否共享地址空间。独居(进程)；合租(线程)。 线程：最小的执行单位 进程：最小分配资源单位，可看成是只有一个线程的进程。
一个线程是一个执行空间，这个空间会被操作系统调度来运行函数中所写的代码。每个进程至少包含一个线程，每个进程的初识线程被称作主线程。因为执行这个线程的空间是应用程序本身的空间，所以在主线程终止时，应用程序也会终止。操作系统将线程调度到某个处理器上运行，这个处理器并不一定是进程所在的处理器。不同的操作系统使用的线程调度算法一般都不一样，但这种不同会被操作系统屏蔽，并不会展示给程序员。
(1)线程同步 同步即协同步调，按预定的先后次序运行。 线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。 举例1：银行存款5000。柜台，折：取3000；提款机，卡：取3000。剩余：2000 举例2：内存中100字节，线程T1欲填入全1，线程T2欲填入全0。但如果T1执行了50个字节失去cpu，T2执行，会将T1写过的内容覆盖。当T1再次获得cpu继续 从失去cpu的位置向后写入1，当执行结束，内存中的100字节，既不是全1，也不是全0。 产生的现象叫做"与时间有关的错误"(time related)。为了避免这种数据混乱，线程需要同步。 "同步"的目的，是为了避免数据混乱，解决与时间有关的错误。实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。 因此，所有"多个控制流，共同操作一个共享资源"的情况，都需要同步，同步的方式一般是加锁(这个会在后面介绍道)。
2.3 协成并发协程：coroutine。也叫轻量级线程。 与传统的系统级线程和进程相比，协程最大的优势在于“轻量级”。可以轻松创建上万个而不会导致系统资源衰竭。而线程和进程通常很难超过1万个。这也是协程别称“轻量级线程”的原因。 一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。 多数语言在语法层面并不直接支持协程，而是通过库的方式支持，但用库的方式支持的功能也并不完整，比如仅仅提供协程的创建、销毁与切换等能力。如果在这样的轻量级线程中调用一个同步IO 操作，比如网络通信、本地文件读写，都会阻塞其他的并发执行轻量级线程，从而无法真正达到轻量级线程本身期望达到的目标。 在协程中，调用一个任务就像调用一个函数一样，消耗的系统资源最少！但能达到进程、线程并发相同的效果。 在一次并发任务中，进程、线程、协程均可以实现。从系统资源消耗的角度出发来看，进程相当多，线程次之，协程最少。
三.Go并发Go 在语言级别支持协程，叫goroutine。 goroutine是Go语言并发设计的核心，有人称之为go程。Goroutine从量级上看很像协程，它比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB)，当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。 一般情况下，一个普通计算机跑几十个线程就有点负载过大了，但是同样的机器却可以轻松地让成百上千个goroutine进行资源竞争。 Go语言中的并发指的是能让某个函数独立于其他函数运行的能力。当一个函数创建为goroutine时，Go会将其视为一个独立的工作单元。这个单元会被调度到可用的逻辑处理器上执行。Go语言运行时的调度器是一个复杂的软件，能管理被创建的所有goroutine并为其分配执行时间。这个调度器在操作系统之上，将操作系统线程和语言运行时的逻辑处理器绑定，并在逻辑处理器上运行goroutine。调度器在任何给定的时间，都会全面控制哪个goroutine要在哪个逻辑处理器上运行。 Go语言的并发同步模型来自一个叫做通信顺序进程(Communicating Sequential Process，CSP)的范型(paradigm)。CSP是一种消息传递模型，通过在goroutine之间传递数据来传递消息，而不是对数据进行加锁来实现同步访问。用于在goroutine之间同步和传递数据的关键数据类型叫做通道(channel，这个会在后面讲到)。使用通道可以使编写并发程序更容易，也能够让并发程序更少出错。 操作系统会在物理处理器上调度线程来运行，而Go语言在运行时会在逻辑处理器上调度goroutine来运行。每个逻辑处理器都会分别绑定到单个操作系统线程。在1.5版本上，Go语言的运行默认会为每个可用的物理处理器分配一个逻辑处理器。在1.5版本之前的版本中，默认给整个应用程序只分配一个逻辑处理器。这些逻辑处理器会用于执行所用被创建的goroutine。即便只有一个逻辑处理器，Go也可以以神奇的效率和性能，并发调度无数个goroutine。 在下图中，可以看到操作系统线程，逻辑处理器和本地运行队列之间的关系。如果创建一个goroutine并准备运行，这个goroutine就会被放到调度器的全局运行队列中。之后，调度器就会将这些队列中的goroutine分配给一个逻辑处理器，并放到这个逻辑处理器对应的本地运行队列中。本地运行队列中的goroutine会一直等待直到自己被分配到逻辑处理器执行。
有时，正在运行的goroutine需要执行一个阻塞的系统调用，如打开一个文件。当这类调用发生时，线程和goroutine会从逻辑处理器上分离，该线程会继续阻塞，等待系统调用的返回。与此同时，这个逻辑处理器就会失去了用来运行的线程。所以，调度器会创建一个新线程，并将其绑定到该逻辑处理器上。之后，调度器会从本地运行队列里选择另一个goruntine来运行。一旦被阻塞的系统调用执行完并返回，对应的goruntine就会放回到本地运行队列中，而之前的线程会保存好，以便之后可以继续使用。
(1)创建goroutine 只需在函数调⽤语句前添加go 关键字，就可创建并发执⾏单元。开发⼈员无需了解任何执⾏细节，调度器会自动将其安排到合适的系统线程上执行。 在并发编程中，我们通常想将一个过程切分成几块，然后让每个goroutine各自负责一块工作，当一个程序启动时，主函数在一个单独的goroutine中运行，我们叫它main goroutine。新的goroutine会用go语句来创建。而go语言的并发设计，让我们很轻松就可以达成这一目的。 示例如下： import (
"fmt"
"time"
)
func singing() {
for i := 0;i < 5;i++{
fmt.Println("----正在唱歌：人猿泰山----")
time.Sleep(time.Millisecond * 30)
}
}
func danceing() {
for j := 0;j < 5;j++{
fmt.Println("====正在跳舞：赵四街舞====")
time.Sleep(time.Millisecond * 30)
}
}
func main() {
go singing()
go danceing()
}
但这时我们执行发现并没有内容输出，是我们的语法有什么问题吗，并不是，是因为在主go程启动两个子go程后，主go程就结束了，，所以就没有结果输出了，这就是goruntine的特性：主goroutine退出后，其它的工作goroutine也会自动退出 为了防止这种现象，我们需要主go程后于子go程结束，我们暂时先可以在主go程中加上死循环，等后面介绍过通道后，就可以用通道来实现控制主子go程结束的先后循序。 package main
import (
"fmt"
"runtime"
"time"
)
func singing() {
for i := 0;i < 5;i++{
fmt.Println("----正在唱歌：人猿泰山----")
time.Sleep(time.Millisecond * 30)
}
}
func danceing() {
for j := 0;j < 5;j++{
fmt.Println("====正在跳舞：赵四街舞====")
time.Sleep(time.Millisecond * 30)
}
}
func main() {
go singing()
go danceing()
结果如下： ----正在唱歌：人猿泰山---- ====正在跳舞：赵四街舞==== ----正在唱歌：人猿泰山---- ====正在跳舞：赵四街舞==== ====正在跳舞：赵四街舞==== ----正在唱歌：人猿泰山---- ====正在跳舞：赵四街舞==== ----正在唱歌：人猿泰山---- ----正在唱歌：人猿泰山---- ====正在跳舞：赵四街舞==== 通过发现程序中的子go程是并行执行的。
(2)Goexit()函数 调用runtime.Goexit() 将立即终止当前goroutine 执⾏，调度器确保所有已注册defer 延迟调用被执行。 import (
"fmt"
"runtime"
"time"
)
func test() {
defer fmt.Println("子go程结束")
fmt.Println("子go程即将结束")
runtime.Goexit()
}
func main() {
//匿名子go程
go func() {
for i := 0;i < 10;i++{
fmt.Println(i)
if i == 5{
test()
}
time.Sleep(time.Millisecond * 100)
}
}()
for {
runtime.GC()
}
}
结果如下： 0 1 2 3 4 5 子go程即将结束 子go程结束
四.channelchannel是Go语言中的一个核心类型，可以把它看成管道。并发核心单元通过它就可以发送或者接收数据进行通讯，这在一定程度上又进一步降低了编程的难度。 channel是一个数据类型，主要用来解决go程的同步问题以及go程之间数据共享（数据传递）的问题。 goroutine运行在相同的地址空间，因此访问共享内存必须做好同步。goroutine 奉行通过通信来共享内存，而不是共享内存来通信。 引⽤类型channel可用于多个goroutine 通讯。其内部实现了同步，确保并发安全。
4.1 定义channel变量和map类似，channel也一个对应make创建的底层数据结构的引用。 当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者和被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。 定义一个channel时，也需要定义发送到channel的值的类型。channel可以使用内置的make()函数来创建： make(chan Type) //等价于make(chan Type, 0) make(chan Type, capacity) chan是创建channel所需使用的关键字。Type 代表指定channel收发数据的类型。 例子： ch1 := make(chan int) ch2 := make(chan string,0) 当参数capacity=0 时，channel是无缓冲阻塞读写的；当capacity > 0 时，channel 有缓冲、是非阻塞的，直到写满capacity个元素才阻塞写入。
channel非常像生活中的管道，一边可以存放东西，另一边可以取出东西。channel通过操作符<- 来接收和发送数据，发送和接收数据语法： 读channel：
写channel：
channel的特性：
通道中的数据只能读取一次，不能重复读。先进先出。
读端 和 写端在不同的 goroutine 之间。
读端读，写端不在线，读端阻塞。写端写，读端不在线，写端阻塞。
默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变的更加的简单，而不需要显式的lock。 示例如下： import (
"fmt"
"time"
)
func main() {
ch := make(chan string)
go func() {
defer fmt.Println("子go程结束，写数据给主go程")
for i := 0;i < 3;i++{
fmt.Println(i)
time.Sleep(time.Second * 2)
}
ch <- "子go程打印3次数据完毕"
}()
str := <- ch
fmt.Println("主go程接收到数据:",str)
}
结果如下： 0 1 2 子go程结束，写数据给主go程 主go程接收到数据: 子go程打印3次数据完毕 我们发现主go程在子go程输出完三次数据后才结束，我们并没有在主go程中添加死循环来让主go程后于子go程结束，只是通过通道实现了控制两个go程到执行顺序。
通道channel不仅可以实现goruntine之间的同步，还可以实现goruntine之间的数据通信，示例如下： import "fmt"
func main() {
//通道ch1：用于两个goruntine之间传递数据
ch1 := make(chan int)
//通道ch2：协调两个goruntine之间使用stdout
ch2 := make(chan bool)
//定义匿名子go程
go func() {
for i := 0;i < 3;i++{
ch1 <- i
fmt.Println("子go程向主go程传递:",i)
ch2 <- false
}
}()
//因为子go程向主go程传递3次数据，所以主go程要循环3次接收
for j := 0;j < 3;j++{
num := <- ch1
<- ch2
fmt.Println("主go程读到:",num)
}
}
结果如下： 子go程向主go程传递: 0 主go程读到: 0 子go程向主go程传递: 1 主go程读到: 1 子go程向主go程传递: 2 主go程读到: 2 上面的程序定义通道ch2的目的是为协调主子go程使用标准输出的顺序，子go程先使用标准输出，因为在这里标准输出是公共资源，多个go程调用公共资源需要同步，否则就会发生竞争。
4.2 无缓冲channel无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何数据值的通道。 这种类型的通道要求发送goroutine和接收goroutine同时准备好，才能完成发送和接收操作。否则，通道会导致先执行发送或接收操作的goroutine 阻塞等待。 这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。 阻塞：由于某种原因数据没有到达，当前go程（线程）持续处于等待状态，直到条件满足，才解除阻塞。 同步：在两个或多个go程（线程）间，保持数据内容一致性的机制。 下图展示两个goroutine 如何利用无缓冲的通道来共享一个值： 在第1步：两个goruntine都到达通道，但哪个都没有开始执行发送或者接受。 在第2步：左侧的goruntine将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个goruntine会在通道中被锁住，知道交换完成。 在第3步：右侧的goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个goroutine 一样也会在通道中被锁住，直到交换完成。 在第4 步和第5 步，进行交换，并最终，在第6 步，两个goroutine都将它们的手从通道里拿出来，这模拟了被锁住的goroutine 得到释放。两个goroutine 现在都可以去做其他事情了。
无缓冲的channel创建格式： make(chan Type) //等价于make(chan Type, 0) 如果没有指定缓冲区容量，那么该通道就是同步的，因此会阻塞到发送者准备好发送和接收者准备好接收。 示例代码： import (
"fmt"
)
func main() {
//定义无缓冲channel
ch1 := make(chan int) //等价于：ch := make(chan int,0)
ch2 := make(chan bool)
fmt.Println("len=",len(ch1),"cap=",cap(ch1))
go func() {
for i := 0;i < 5;i++{
ch1 <- i
fmt.Println("---- len=",len(ch1),"cap=",cap(ch1),"i=",i)
ch2 <- false
}
}()
for j := 0;j < 5;j++{
num := <- ch1
<- ch2
fmt.Println("==== len=",len(ch1),"cap=",cap(ch1),"num=",num)
}
}
结果如下： len= 0 cap= 0 ---- len= 0 cap= 0 i= 0 ==== len= 0 cap= 0 num= 0 ---- len= 0 cap= 0 i= 1 ==== len= 0 cap= 0 num= 1 ---- len= 0 cap= 0 i= 2 ==== len= 0 cap= 0 num= 2 ---- len= 0 cap= 0 i= 3 ==== len= 0 cap= 0 num= 3 ---- len= 0 cap= 0 i= 4 ==== len= 0 cap= 0 num= 4
4.3 有缓冲的channel有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个数据值的通道。 这种类型的通道并不强制要求goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也不同。 只有通道中没有要接收的值时，接收动作才会阻塞。 只有通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。 这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的goroutine 会在同一时间进行数据交换；有缓冲的通道没有这种保证。 示例图如下： 在第1 步，右侧的goroutine 正在从通道接收一个值。 在第2 步，右侧的这个goroutine独立完成了接收值的动作，而左侧的goroutine 正在发送一个新值到通道里。 在第3 步，左侧的goroutine 还在向通道发送新值，而右侧的goroutine 正在从通道接收另外一个值。这个步骤里的两个操作既不是同步的，也不会互相阻塞。 最后，在第4 步，所有的发送和接收都完成，而通道里还有几个值，也有一些空间可以存更多的值。
有缓冲的channel创建格式： make(chan Type, capacity) 如果给定了一个缓冲区容量，通道就是异步的。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞地进行。 借助函数len(ch)求取缓冲区中剩余元素个数，cap(ch) 求取缓冲区元素容量大小。 示例如下： import ( 结果如下： len= 0 cap= 3 ---- len= 1 cap= 3 i= 0 ---- len= 2 cap= 3 i= 1 ---- len= 3 cap= 3 i= 2 ==== len= 3 cap= 3 num= 0 ---- len= 3 cap= 3 i= 3 ==== len= 2 cap= 3 num= 1 ==== len= 2 cap= 3 num= 2 ==== len= 1 cap= 3 num= 3 ==== len= 0 cap= 3 num= 4 ---- len= 3 cap= 3 i= 4 ---- len= 0 cap= 3 i= 5 ---- len= 1 cap= 3 i= 6 ==== len= 1 cap= 3 num= 5 ==== len= 0 cap= 3 num= 6
4.4 关闭channel如果发送者知道，没有更多的值需要发送到channel的话，那么让接收者也能及时知道没有多余的值可接收将是有用的，因为接收者可以停止不必要的接收等待。这可以通过内置的close函数来关闭channel实现。 示例如下： import "fmt"
func main() {
ch := make(chan int)
go func() {
for i := 0;i < 5;i++{
ch <- i
}
close(ch)
}()
for{
if data,status := <- ch;status{
fmt.Println(data)
}else {
break
}
}
fmt.Println("Finished")
}
结果如下： 0 1 2 3 4 Finished 注意： channel不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的，才去关闭channel； 关闭channel后，无法向channel 再发送数据(引发panic 错误后导致接收立即返回零值)； 关闭channel后，可以继续从channel接收数据； 对于nil channel，无论收发都会被阻塞。
也可以使用range来迭代不断操作channel： import (
"fmt"
)
func main() {
ch := make(chan int)
go func() {
for i := 0;i < 5;i++{
ch <- i
}
close(ch)
}()
for data := range ch{
fmt.Println(data)
}
fmt.Println("Finished")
}
4.5 单项channel默认情况下，通道channel是双向的，也就是，既可以往里面发送数据也可以同里面接收数据。 但是，我们经常见一个通道作为参数进行传递而只希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。
单向channel变量的声明非常简单，如下： var ch1 chan int // ch1是一个正常的channel，是双向的 var ch2 chan<- float64 // ch2是单向channel，只用于写float64数据 var ch3 <-chan int // ch3是单向channel，只用于读int数据 chan<- 表示数据进入管道，要把数据写进管道，对于调用者就是输出。 <-chan 表示数据从管道出来，对于调用者就是得到管道的数据，当然就是输入。
可以将channel 隐式转换为单向队列，只收或只发，不能将单向channel 转换为普通channel： c := make(chan int, 3) var send chan<- int = c // send-only var recv <-chan int = c // receive-only send <- 1 //<-send //invalid operation: <-send (receive from send-only type chan<- int) <-recv //recv <- 2 //invalid operation: recv <- 2 (send to receive-only type <-chan int)
单项channel示例如下： import (
"fmt"
)
func sendto(out chan <- int) {
for i := 0;i < 5;i++{
out <- i
}
close(out)
}
func receivefrom(in <- chan int) {
for data := range in{
fmt.Println("从子go程接收到:",data)
}
}
func main() {
ch := make(chan int)
go sendto(ch)
receivefrom(ch)
}
结果如下： 从子go程接收到: 0 从子go程接收到: 1 从子go程接收到: 2 从子go程接收到: 3 从子go程接收到: 4
(1)生产者和消费者模型 单向channel最典型的应用是“生产者消费者模型” 所谓“生产者消费者模型”: 某个模块（函数等）负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、go程、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。 单单抽象出生产者和消费者，还够不上是生产者／消费者模型。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。大概的结构如下图： 举一个寄信的例子来辅助理解一下，假设你要寄一封平信，大致过程如下： 1．把信写好——相当于生产者制造数据 2．把信放入邮筒——相当于生产者把数据放入缓冲区 3．邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区 4．邮递员把信拿去邮局做相应的处理——相当于消费者处理数据 那么，这个缓冲区有什么用呢？为什么不让生产者直接调用消费者的某个函数，直接把数据传递过去，而画蛇添足般的设置一个缓冲区呢？ 缓冲区的好处大概如下： 1：解耦 假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。将来如果消费者的代码发生变化，可能会直接影响到生产者。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合度也就相应降低了。 接着上述的例子，如果不使用邮筒（缓冲区），须得把信直接交给邮递员。那你就必须要认识谁是邮递员。这就产生和你和邮递员之间的依赖（相当于生产者和消费者的强耦合）。万一哪天邮递员换人了，你还要重新认识下一个邮递员（相当于消费者变化导致修改生产者代码）。而邮筒相对来说比较固定，你依赖它的成本也比较低（相当于和缓冲区之间的弱耦合）。 2：处理并发 生产者直接调用消费者的某个方法，还有另一个弊端。由于函数调用是同步的（或者叫阻塞的），在消费者的方法没有返回之前，生产者只好一直等在那边。万一消费者处理数据很慢，生产者只能无端浪费时间。 使用了生产者／消费者模式之后，生产者和消费者可以是两个独立的并发主体。生产者把制造出来的数据往缓冲区一丢，就可以再去生产下一个数据。基本上不用依赖消费者的处理速度。 其实最当初这个生产者消费者模式，主要就是用来处理并发问题的。 从寄信的例子来看。如果没有邮筒，你得拿着信傻站在路口等邮递员过来收（相当于生产者阻塞）；又或者邮递员得挨家挨户问，谁要寄信（相当于消费者轮询）。 3：缓存 如果生产者制造数据的速度时快时慢，缓冲区的好处就体现出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。 假设邮递员一次只能带走1000封信。万一某次碰上情人节送贺卡，需要寄出去的信超过1000封，这时候邮筒这个缓冲区就派上用场了。邮递员把来不及带走的信暂存在邮筒中，等下次过来时再拿走。
示例如下： import "fmt"
//定义生产者
func producer(in chan <- int) {
for i := 0;i < 10;i++{
fmt.Println("------生产了:",i)
in <- i
}
close(in)
}
//定义消费者
func consumer(out <- chan int) {
for data := range out{
fmt.Println("======消费了:",data*data)
}
}
func main() {
//定义公共区(缓冲区)
ch := make(chan int,5)
//生成生产者
go producer(ch)
//生成消费者
consumer(ch)
}
结果如下： ------生产了: 0 ------生产了: 1 ======消费了: 0 ======消费了: 1 ------生产了: 2 ------生产了: 3 ------生产了: 4 ------生产了: 5 ------生产了: 6 ======消费了: 4 ======消费了: 9 ======消费了: 16 ======消费了: 25 ======消费了: 36 ------生产了: 7 ------生产了: 8 ------生产了: 9 ======消费了: 49 ======消费了: 64 ======消费了: 81 简单说明：首先创建一个双向的channel，然后开启一个新的goroutine，把双向通道作为参数传递到producer方法中，同时转成只写通道。子go程开始执行循环，向只写通道中添加数据，这就是生产者。主go程，直接调用consumer方法，该方法将双向通道转成只读通道，通过循环每次从通道中读取数据，这就是消费者。 注意：channel作为参数传递，是引用传递。
4.6 定时器(1)time.Timer Timer是一个定时器。代表未来的一个单一事件，你可以告诉timer你要等待多长时间。 type Timer struct {
C <-chan Time
r runtimeTimer
}
它提供一个channel，在定时时间到达之前，没有数据写入timer.C会一直阻塞。直到定时时间到，系统会自动向timer.C 这个channel中写入当前时间，阻塞即被解除。 示例如下： func main() {
//创建定时器，指定定时时长
timer := time.NewTimer(time.Second * 3)
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
// 从 timer的 C 中读. 定时时间到达后,系统会自动写入当前时间到 C 中
t := <- timer.C
fmt.Println(t.Format("2006-01-02 15:04:05"))
}
结果如下： 2019-07-19 20:19:36 2019-07-19 20:19:39
time.After()可以合并上面两个步骤 func main() {
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
//把3秒后的时间写入到t中
t := <- time.After(time.Second * 3)
fmt.Println(t.Format("2006-01-02 15:04:05"))
}
结果如下： 2019-07-19 20:22:31 2019-07-19 20:22:34
time.Stop()可以停止定时器 func main() {
timer := time.NewTimer(time.Second * 5)
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
//停止计时器
timer.Stop()
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
}
结果如下： 2019-07-19 20:27:06 2019-07-19 20:27:06
timer.Reset()可以重置定时器 func main() {
timer := time.NewTimer(time.Second * 5)
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
//重制计时器
timer.Reset(time.Second * 2)
t := <- timer.C
fmt.Println(t.Format("2006-01-02 15:04:05"))
}
结果如下： 2019-07-19 20:31:45 2019-07-19 20:31:47
(2)time.Ticker Ticker是一个周期触发定时的计时器，它会按照一个时间间隔往channel发送系统当前时间，而channel的接收者可以以固定的时间间隔从channel中读取事件。 func main() {
//控制主子go程结束的先后顺序
ch := make(chan bool)
timer := time.NewTicker(time.Second * 1)
i := 0
go func() {
for{
<-timer.C
i++
fmt.Println("i = ",i)
if i == 5{
timer.Stop()
ch <- false
runtime.Goexit()
}
}
}()
<-ch
}
结果如下： i = 1 i = 2 i = 3 i = 4 i = 5
五.selectGo里面提供了一个关键字select，通过select可以监听channel上的数据流动。 有时候我们希望能够借助channel发送或接收数据，并避免因为发送或者接收导致的阻塞，尤其是当channel没有准备好写或者读时。select语句就可以实现这样的功能。 select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。 与switch语句相比，select有比较多的限制，其中最大的一条限制就是每个case语句里必须是一个IO操作，大致的结构如下： select {
case <- chan1:
// 如果chan1成功读到数据，则进行该case处理语句
case chan2 <- 1:
// 如果成功向chan2写入数据，则进行该case处理语句
default:
// 如果上面都没有成功，则进入default处理流程
}
1.每一个case分支，都必须一个 IO操作（channel r/w事件）。 2.通常将 select 置于 for 循环中。 3.一个case监听的 channel 不满足监听条件。当前case分支阻塞。 4.当所有case分支都不满足监听条件时，select如果包含default分支，走default；如果没有default，select等待case。 5.当监听的多个case分支中，同时有多个case满足，随机选择任一一个执行。 6.为防止忙轮询，可以适当选择省略 default 示例如下： import (
"fmt"
"runtime"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan bool)
go func() {
for{
fmt.Println("===================")
select {
case num := <- ch1:
fmt.Println("num = ",num)
case ch2 <- false:
fmt.Println("子go程结束")
runtime.Goexit()
}
}
}()
for i := 0;i < 10;i++{
ch1 <- i
if i == 5{
<- ch2
break
}
}
fmt.Println("finish")
}
结果如下： =================== num = 0 =================== num = 1 =================== num = 2 =================== num = 3 =================== num = 4 =================== num = 5 =================== finish 子go程结束
之后用select实现输出斐波那契数列的前15位，代码如下： import (
"fmt"
"runtime"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan bool)
go func() {
for{
select {
case num := <- ch1:
fmt.Println(num)
case ch2 <- false:
runtime.Goexit()
}
}
}()
x,y := 1,1
for i := 0;i < 15;i++{
ch1 <- x
x,y = y,x+y
}
<-ch2
}
得到结果如下： 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现： 监听超时定时器：case <-time.After(time.Second * 3) 当select监听的其他case分支满足时，time.After所在的case分支，会被重置成初始定时时长。
示例如下： import (
"fmt"
"time"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan bool)
go func() {
for{
select {
case num := <- ch1:
fmt.Println("num = ",num)
case <- time.After(time.Second * 3):
fmt.Println("子go程读到系统时间, 定时满 3 秒")
ch2 <- false
}
}
}()
for i := 0;i < 2;i++{
ch1 <- i
time.Sleep(time.Second*2)
}
<-ch2
fmt.Println("finish")
}
六.锁和条件变量前面我们为了解决go程同步的问题我们使用了channel，但是GO也提供了传统的同步工具，就是锁。 它们都在GO的标准库代码包sync和sync/atomic中。 我们看一下锁的应用。 是锁呢？就是某个go程（线程）在访问某个资源时先锁住，防止其它go程的访问，等访问完毕解锁后其他go程再来加锁进行访问。这和我们生活中加锁使用公共资源相似，例如：公共卫生间。
6.1 死锁首先，死锁不是锁的一种，是错误使用锁的现象。 死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。 先面列举几个造成死锁的现象： (1) 示例如下： func main() {
ch := make(chan int)
ch <- 10
num := <- ch
fmt.Println(num)
}
(2) 示例如下： func main() {
ch := make(chan int)
num := <- ch
go func() {
ch <- 10
}()
fmt.Println(num)
}
(3) func main() {
ch1 := make(chan int)
ch2 := make(chan int)
go func() {
for i := 0;i < 10;i++{
num := <- ch2
fmt.Println(num)
ch1 <- i
}
}()
for data := range ch1{
fmt.Println(data)
ch2 <- 4096
}
}
(4)
每个资源都对应于一个可称为"互斥锁" 的标记，这个标记用来保证在任意时刻，只能有一个go程（线程）访问该资源。其它的go程只能等待。 互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法，Lock和Unlock。Lock锁定当前的共享资源，Unlock进行解锁。 在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助defer。锁定后，立即使用defer语句保证互斥锁及时解锁。如下所示： var mutex sync.Mutex // 定义互斥锁变量 mutex
func write(){
mutex.Lock( )
defer mutex.Unlock( )
}
示例如下： import (
"fmt"
"sync"
"time"
)
//定义互斥锁
var mutex sync.Mutex
//定义一个channel用开控制主，子go程结束的先后顺序
var ch = make(chan bool)
func printer(str string) {
mutex.Lock()
defer mutex.Unlock()
for _,ch := range str{
fmt.Printf("%c",ch)
time.Sleep(time.Millisecond*200)
}
}
func user1() {
printer("hello")
ch <- false
}
func user2() {
printer("world")
ch<- false
}
func main() {
go user1()
go user2()
for i := 0;i < 2;i++{
<-ch
}
}
6.3 读写锁 RWMUTEX互斥锁的本质是当一个goroutine访问的时候，其他goroutine都不能访问。这样在资源同步，避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。 其实，当我们对一个不会变化的数据只做“读”操作的话，是不存在资源竞争的问题的。因为数据是不变的，不管怎么读取，多少goroutine同时读取，都是可以的。 所以问题不是出在“读”上，主要是修改，也就是“写”。修改的数据要同步，这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的。 因此，衍生出另外一种锁，叫做读写锁。 读写锁可以让多个读操作并发，同时读取，但是对于写操作是完全互斥的。也就是说，当一个goroutine进行写操作的时候，其他goroutine既不能进行读操作，也不能进行写操作。 GO中的读写锁由结构体类型sync.RWMutex表示。此类型的方法集合中包含两对方法： 一组是对写操作的锁定和解锁，简称“写锁定”和“写解锁”： func (*RWMutex)Lock() func (*RWMutex)Unlock() 另一组表示对读操作的锁定和解锁，简称为“读锁定”与“读解锁”： func (*RWMutex)RLock() func (*RWMutex)RUnlock() 读写锁基本示例： import (
"fmt"
"math/rand"
"runtime"
"sync"
)
var count int
var rwmutex sync.RWMutex
func Read(n int) {
rwmutex.RLock()
defer rwmutex.RUnlock()
fmt.Printf("读goruntine %d 正在读取数据...\n",n)
num := count
fmt.Printf("读goroutine %d 读取数据结束，读到 %d\n",n,num)
}
func Write(n int) {
rwmutex.Lock()
defer rwmutex.Unlock()
fmt.Printf("写goruntine %d 正在写数据...\n",n)
num := rand.Intn(1000)
count = num
fmt.Printf("写goroutine %d 写数据结束，写入新值 %d\n",n,num)
}
func main() {
for i:=0;i<5;i++{
go Read(i+1)
}
for j:=0;j<5;j++{
go Write(j+1)
}
for{
runtime.GC()
}
}
结果如下： 读goruntine 2 正在读取数据... 读goroutine 2 读取数据结束，读到 0 读goruntine 1 正在读取数据... 读goroutine 1 读取数据结束，读到 0 写goruntine 1 正在写数据... 写goroutine 1 写数据结束，写入新值 81 读goruntine 3 正在读取数据... 读goroutine 3 读取数据结束，读到 81 读goruntine 4 正在读取数据... 读goroutine 4 读取数据结束，读到 81 读goruntine 5 正在读取数据... 读goroutine 5 读取数据结束，读到 81 写goruntine 3 正在写数据... 写goroutine 3 写数据结束，写入新值 887 写goruntine 2 正在写数据... 写goroutine 2 写数据结束，写入新值 847 写goruntine 4 正在写数据... 写goroutine 4 写数据结束，写入新值 59 写goruntine 5 正在写数据... 写goroutine 5 写数据结束，写入新值 81 我们在read里使用读锁，也就是RLock和RUnlock，写锁的方法名和我们平时使用的一样，是Lock和Unlock。这样，我们就使用了读写锁，可以并发地读，但是同时只能有一个写，并且写的时候不能进行读操作。 我们从结果可以看出，读取操作可以并行，例如2,3,1正在读取，但是同时只能有一个写，例如1正在写，只能等待1写完，这个过程中不允许进行其它的操作。 处于读锁定状态，那么针对它的写锁定操作将永远不会成功，且相应的Goroutine也会被一直阻塞。因为它们是互斥的。 总结：读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的。但是，多个读操作之间不存在互斥关系。
6.4 条件变量在讲解条件变量之前，先回顾一下前面我们所涉及的“ |
请发表评论