golang学习九:Go并发编程

Posted 2021-07-16 浅弋、璃鱼

文章目录

• 一、概述:
• • 1. 并行与并发:
• 二、常见并发编程技术:
• • 1.进程并发
  • • 1.1 程序和进程:
    • 1.2 进程状态:
    • 1.2 进程并发
  • 2. 线程并发:
  • • 2.1 什么是线程:
    • 2.2 线程同步:
  • 3. 锁的应用:
  • • 3.1 互斥量 mutex:
    • 3.2 读写锁
  • 4.协程并发:
  • • 4.1 什么是协程:
    • 4.2 Go并发
  • 5. Goroutine
  • • 5.1 什么是Goroutine
    • 5.2 Goroutine的创建
    • 5.3 Goroutine特性:
  • 6. runtime包:
  • • 6.1 Gosched
    • 6.2 Goexit
    • 6.3 GOMAXPROCS
    • 6.4 其他方法:
• 三、协程间通信与 Channel
• • 1. channel同步数据通信:
  • • 1.1 channel 管道:
    • 1.2 什么是channel:
    • 1.3 定义channel变量:
  • 2. 无缓冲的channel:
  • 3. 有缓冲的channel:
  • 4. 关闭channel
  • 5. 单向channel及应用:
  • 6. 生产者消费者模型:
  • • 6.2 模拟订单:
  • 7. 定时器:
  • • 7.1 单次定时器: `time.Timer`
    • 7.2 定时器的常用操作 -- 实现延迟功能:
    • 7.3 定时器的常用操作 -- 定时器停止:
    • 7.4 循环定时器 `time.Ticker`:
  • 8. select:
  • • 8.1 select作用
    • 8.2 超时
• 四、(扩展)锁和条件变量:
• • 1. 死锁
  • 2. 互斥锁:
  • 3. 读写锁:
  • • 读写锁与channel同时使用引起的"隐性死锁":
    • 读写锁实现:
  • 4. 条件变量:

一、概述:

所谓并发编程是指在一台处理器上“同时”处理多个任务;
宏观的并发是指在一段时间内, 有多个程序在同时运行;
并发在微观上, 是指在同一时刻只能有一条指令执行, 但多个程序指令被快速的轮换执行, 使得在宏观上具有多个进程同时执行的效果, 但在微观上并不是同时执行的, 只是把时间分成若干段, 使多个程序快速交替的执行;

1. 并行与并发:

并行(parallel): 指在同一时刻, 有多条指令在多个处理器上同时执行;

并发(concurrency)L指在同一时刻只能有一条指令执行, 但多个进程指令被快速的轮换执行, 使得在宏观上具有多个进程同时执行的效果, 但在微观上并不是同时执行的, 只是把时间分成若干段, 通过cpu时间片轮转使多个进程快速交替的执行;

• 并行是两个队列同时使用两台咖啡机 (真正的多任务)
• 并发是两个队列交替使用一台咖啡机 (假 的多任务)
  

二、常见并发编程技术:

1.进程并发

1.1 程序和进程:

• 程序:
  • 编译成功的得到的二进制文件;
  • 占用: 磁盘
• 进程:
  • 运行起来的程序;
  • 占用系统资源;(内存, 锁, cpu, …)
  • 一个程序可以起多个线程;

1.2 进程状态:

进程基本的状态有5种; 分别为初始态, 就绪态, 运行态, 挂起态与终止态; 其中初始态为进程准备阶段; 常与就绪态结合来看;

1.2 进程并发

在使用进程 实现并发时可能会出现的问题呢:

• 系统开销比较大, 占用资源比较多，开启进程数量比较少;
• 在unix/linux系统下, 还会产生"孤儿进程"和"僵尸进程";

通过前面查看操作系统的进程信息, 在操作系统中, 可以产生很多的进程; 在unix/linux系统中, 正常情况下, 子进程是通过父进程fork创建的, 子进程再创建新的进程;
并且父进程永远无法预测子进程 到底什么时候结束; 当一个 进程完成它的工作终止之后, 它的父进程需要调用系统调用取得子进程的终止状态;

孤儿进程 :

• 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。
  僵尸进程 :
• 进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。
  Windows下的进程和Linux下的进程是不一样的，它比较懒惰，从来不执行任何东西，只是为线程提供执行环境。然后由线程负责执行包含在进程的地址空间中的代码。当创建一个进程的时候，操作系统会自动创建这个进程的第一个线程，成为主线程

2. 线程并发:

2.1 什么是线程:

LWP: light weight process 轻量级的进程, 本质仍是进程 (Linux下)
进程: 独立地址空间，拥有PCB
线程: 有独立的PCB，但没有独立的地址空间(共享)
区别:
- 在于是否共享地址空间;
- 线程: 最小的执行单位;
- 进程: 最小分配资源单位, 可看成是只有一个线程的进程;
Windows系统下, 可以直接忽略进程的概念, 只谈线程; 因为线程是最小的执行单位, 是被系统独立调度和分派的基本单位; 而进程只是给线程提供执行环境;

2.2 线程同步:

同步即协同步调, 按预定的先后次序运行;
线程同步: 指一个线程发出某一功能调用时, 在没有得到结果之前, 该调用不返回; 同时其它线程为保证数据一致性, 不能调用该功能;

举例: 内存中100字节, 线程T1欲填入全1, 线程T2欲填入全0; 但如果T1执行了50个字节失去cpu, T2执行, 会将T1写过的内容覆盖; 当T1再次获得cpu继续从失去cpu的位置向后写入1, 当执行结束, 内存中的100字节, 既不是全1, 也不是全0;
产生的现象叫做与时间有关的错误(time related); 为了避免这种数据混乱,线程需要同步;
“同步”的目的, 是为了避免数据混乱, 解决与时间有关的错误; 实际上, 不仅线程间需要同步, 进程间、信号间等等都需要同步机制;
因此, 所有“多个控制流, 共同操作一个共享资源”的情况, 都需要同步;

3. 锁的应用:

3.1 互斥量 mutex:

Linux中提供一把互斥锁mutex(也称之为互斥量);
每个线程在对资源操作前都尝试先加锁, 成功加锁才能操作, 操作结束解锁;
资源还是共享的, 线程间也还是竞争的, 但通过“锁”就将资源的访问变成互斥操作, 而后与时间有关的错误也不会再产生了;

应注意: 同一时刻, 只能有一个线程持有该锁;
当A线程对某个全局变量加锁访问, B在访问前尝试加锁, 拿不到锁, B阻塞; C线程不去加锁, 而直接访问该全局变量, 依然能够访问, 但会出现数据混乱;
所以, 互斥锁实质上是操作系统提供的一把“建议锁”(又称“协同锁”), 建议程序中有多线程访问共享资源的时候使用该机制; 但, 并没有强制限定;
因此, 即使有了mutex, 如果有线程不按规则来访问数据, 依然会造成数据混乱;

3.2 读写锁

与互斥量类似, 但读写锁允许更高的并行性; 其特性为: 写独占, 读共享:

• 读写锁状态: 读写锁只有一把, 其具备两种状态:

  • 读模式下加锁状态 (读锁);
  • 写模式下加锁状态 (写锁);

• 读写锁特性:

  • 读写锁是“写模式加锁”时, 解锁前, 所有对该锁加锁的线程都会被阻塞;
  • 读写锁是“读模式加锁”时, 如果线程以读模式对其加锁会成功; 如果线程以写模式加锁会阻塞;
  • 读写锁是“读模式加锁”时, 既有试图以写模式加锁的线程, 也有试图以读模式加锁的线程; 那么读写锁会阻塞随后的读模式锁请求; 优先满足写模式锁; 读锁、写锁并行阻塞, 写锁优先级高;

读写锁也叫共享-独占锁; 当读写锁以读模式锁住时, 它是以共享模式锁住的; 当它以写模式锁住时, 它是以独占模式锁住的; 写独占、读共享;
读写锁非常适合于对数据结构读的次数远大于写的情况;

4.协程并发:

4.1 什么是协程:

协程: coroutine, 也叫轻量级线程;
与传统的系统级线程和进程相比, 协程最大的优势在于“轻量级”; 可以轻松创建上万个而不会导致系统资源衰竭; 而线程和进程通常很难超过1万个; 这也是协程别称“轻量级线程”的原因;
一个线程中可以有任意多个协程, 但某一时刻只能有一个协程在运行, 多个协程分享该线程分配到的计算机资源;
多数语言在语法层面并不直接支持协程, 而是通过库的方式支持, 但用库的方式支持的功能也并不完整, 比如仅仅提供协程的创建、销毁与切换等能力; 如果在这样的轻量级线程中调用一个同步 IO 操作, 比如网络通信、本地文件读写, 都会阻塞其他的并发执行轻量级线程, 从而无法真正达到轻量级线程本身期望达到的目标;
在协程中, 调用一个任务就像调用一个函数一样, 消耗的系统资源最少! 但能达到进程、线程并发相同的效果;
在一次并发任务中, 进程、线程、协程均可以实现; 从系统资源消耗的角度出发来看, 进程相当多, 线程次之, 协程最少;

4.2 Go并发

Go 在语言级别支持协程, 叫goroutine; Go 语言标准库提供的所有系统调用操作(包括所有同步IO操作), 都会出让CPU给其他goroutine; 这让轻量级线程的切换管理不依赖于系统的线程和进程, 也不需要依赖于CPU的核心数量;
有人把Go比作21世纪的C语言; 第一是因为Go语言设计简单, 第二21世纪最重要的就是并行程序设计, 而Go从语言层面就支持并行; 同时, 并发程序的内存管理有时候是非常复杂的, 而Go语言提供了自动垃圾回收机制;
Go语言为并发编程而内置的上层API基于顺序通信进程模型CSP(communicating sequential processes); 这就意味着显式锁都是可以避免的, 因为Go通过相对安全的通道发送和接受数据以实现同步, 这大大地简化了并发程序的编写;
Go语言中的并发程序主要使用两种手段来实现; goroutine和channel;

5. Goroutine

5.1 什么是Goroutine

goroutine是Go并行设计的核心; goroutine说到底其实就是协程, 它比线程更小, 十几个goroutine可能体现在底层就是五六个线程, Go语言内部实现了这些goroutine之间的内存共享; 执行goroutine只需极少的栈内存(大概是4~5KB), 当然会根据相应的数据伸缩; 也正因为如此, 可同时运行成千上万个并发任务; goroutine比thread更易用、更高效、更轻便;
一般情况下, 一个普通计算机跑几十个线程就有点负载过大了, 但是同样的机器却可以轻松地让成百上千个goroutine进行资源竞争;

5.2 Goroutine的创建

只需在函数调⽤语句前添加 go 关键字, 就可创建并发执⾏单元; 开发⼈员无需了解任何执⾏细节, 调度器会自动将其安排到合适的系统线程上执行;
在并发编程中, 通常想将一个过程切分成几块, 然后让每个goroutine各自负责一块工作, 当一个程序启动时, 主函数在一个单独的goroutine中运行, 叫main goroutine; 新的goroutine会用go语句来创建; 而go语言的并发设计, 很轻松就可以达成这一目的;

package main

import (
    "fmt"
    "time"
)

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

func main() {
    //创建一个 goroutine，启动另外一个任务
    go newTask()
    i := 0
    //main goroutine 循环打印
    for {
        i++
        fmt.Printf("main goroutine: i = %d\\n", i)
        time.Sleep(1 * time.Second) //延时1s
    }
}

5.3 Goroutine特性:

主goroutine退出后，其它的工作goroutine也会自动退出;

6. runtime包:

6.1 Gosched

runtime.Gosched() 用于让出CPU时间片, 让出当前goroutine的执行权限, 调度器安排其他等待的任务运行, 并在下次再获得cpu时间轮片的时候, 从该出让cpu的位置恢复执行;

package main

import (
"fmt"
"runtime"
)

func main() {
    //创建一个goroutine
    go func(s string) {
        for i := 0; i < 2; i++ {
            fmt.Println(s)
        }
    }("world")

    for i := 0; i < 2; i++ {
        runtime.Gosched()  //import "runtime" 包
        /*
            屏蔽runtime.Gosched()运行结果如下：
                hello
                hello

            有runtime.Gosched()运行结果如下：
                world
                world
                hello
                hello
        */
        fmt.Println("hello")
    }
}

主协程进入main()函数, 进行代码的执行; 当执行到go func()匿名函数时, 创建一个新的协程, 开始执行匿名函数中的代码, 主协程继续向下执行, 执行到runtime.Gosched()时会暂停向下执行, 直到其它协程执行完后, 再回到该位置, 主协程继续向下执行;

6.2 Goexit

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

package main

import (
"fmt"
"runtime"
)

func main() {
    go func() {
        defer fmt.Println("A.defer")

        func() {
            defer fmt.Println("B.defer")
            runtime.Goexit() // 终止当前 goroutine, import "runtime"
            fmt.Println("B") // 不会执行
        }()

        fmt.Println("A") // 不会执行
    }() 	//不要忘记()

    //死循环，目的不让主goroutine结束
    for {
    }
}

结果:

B.defer
A.defer

6.3 GOMAXPROCS

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

package main

import (
    "fmt"
)

func main() {
//n := runtime.GOMAXPROCS(1) 	// 第一次 测试
//打印结果：111111111111111111110000000000000000000011111...

n := runtime.GOMAXPROCS(2)         // 第二次 测试
//打印结果：010101010101010101011001100101011010010100110...
    fmt.Printf("n = %d\\n", n)

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

在第一次执行runtime.GOMAXPROCS(1) 时, 最多同时只能有一个goroutine被执行, 所以会打印很多1; 过了一段时间后, GO调度器会将其置为休眠, 并唤醒另一个goroutine, 这时候就开始打印很多0了, 在打印的时候, goroutine是被调度到操作系统线程上的;
在第二次执行runtime.GOMAXPROCS(2) 时, 使用了两个CPU, 所以两个goroutine可以一起被执行, 以同样的频率交替打印0和1;

6.4 其他方法:

https://studygolang.com/pkgdoc

三、协程间通信与 Channel

1. channel同步数据通信:

1.1 channel 管道:

补充知识:
每当有一个进程启动时, 系统会自动打开三个文件: 标准输入、标准输出、标准错误; —— 对应三个文件: stdin(代号: 0)、stdout(代号: 1)、stderr(代号: 2);
当进行运行结束, 操作系统自动关闭三个文件(隐式回收系统资源),

1.2 什么是channel:

channel是Go语言中的一个核心类型, 可以把它看成管道; 并发核心单元通过它就可以发送或者接收数据进行通讯, 这在一定程度上又进一步降低了编程的难度;
channel是一个数据类型, 主要用来解决协程的同步问题以及协程之间数据共享(数据传递)的问题;
goroutine运行在相同的地址空间, 因此访问共享内存必须做好同步; goroutine 奉行通过通信来共享内存, 而不是共享内存来通信;
引⽤类型 channel可用于多个 goroutine 通讯; 其内部实现了同步, 确保并发安全;

1.3 定义channel变量:

和map类似, channel也一个对应make创建的底层数据结构的引用;
当复制一个channel或用于函数参数传递时, 只是拷贝了一个channel引用, 因此调用者和被调用者将引用同一个channel对象; 和其它的引用类型一样, channel的零值也是nil;
定义一个channel时, 也需要定义发送到channel的值的类型; channel可以使用内置的make()函数来创建:
- chan是创建channel所需使用的关键字;
- Type 代表指定channel收发数据的类型;

make(chan Type)  // 等价于make(chan Type, 0) => 无缓冲,只能容纳一个变量
make(chan Type, capacity) // => 有缓冲通道

当 capacity = 0 时, channel 是无缓冲阻塞读写的;
当 capacity > 0 时, channel 有缓冲、是非阻塞的, 直到写满 capacity个元素才阻塞写入;

channel一边可以存放东西, 另一边可以取出东西; channel通过操作符 <- 来接收和发送数据;
发送和接收数据语法:

channel <- value      //发送value到channel

<-channel             //接收并将其丢弃
x := <-channel        //从channel中接收数据，并赋值给x
x, ok := <-channel    //功能同上，同时检查通道是否已关闭或者是否为空

默认情况下, channel接收和发送数据都是阻塞的, 除非另一端已经准备好, 这样就使得goroutine同步变的更加的简单, 而不需要显式的lock;

package main

import (
    "fmt"
)

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

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

        fmt.Println("子协程正在运行……")

        c <- 666 //666发送到c
    }()

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

    fmt.Println("num = ", num)
    fmt.Println("main协程结束")
}

结果:

子协程正在运行......
子协程结束
num = 666
main协程结束

2. 无缓冲的channel:

无缓冲的通道(unbuffered channel)是指在接收前没有能力保存任何值的通道;
这种类型的通道要求发送goroutine和接收goroutine同时准备好, 才能完成发送和接收操作; 否则, 通道会导致先执行发送或接收操作的 goroutine 阻塞等待;
这种对通道进行发送和接收的交互行为本身就是同步的; 其中任意一个操作都无法离开另一个操作单独存在;

• 阻塞：由于某种原因数据没有到达，当前协程（线程）持续处于等待状态，直到条件满足，才接触阻塞;
• 同步：在两个或多个协程(线程)间, 保持数据内容一致性的机制;

无缓冲的channel创建格式:

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

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

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int, 0) //创建无缓冲的通道 c 

    //内置函数 len 返回未被读取的缓冲元素数量，cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d\\n", len(c), cap(c))

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

        for i := 0; i < 3; i++ {
            c <- i
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\\n", i, len(c), cap(c))
        }
    }()

    time.Sleep(2 * time.Second) //延时2s

    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据，并赋值给num
        fmt.Println("num = ", num)
    }

    fmt.Println("main协程结束")
}

结果:

lan(c)=0, cap(c)=0
子协程正在运行[0]: len(c)=0, cap(c)=0
num = 0
num = 1
子协程正在运行[1]: len(c)=0, cap(c)=0
子协程正在运行[2]: len(c)=0, cap(c)=0
子协程结束
num = 2
main协程结束

3. 有缓冲的channel:

有缓冲的通道(buffered channel)是一种在被接收前能存储一个或者多个数据值的通道;
这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收; 通道会阻塞发送和接收动作的条件也不同;
只有通道中没有要接收的值时, 接收动作才会阻塞;
只有通道没有可用缓冲区容纳被发送的值时, 发送动作才会阻塞;
这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同:

• 无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换;
• 有缓冲的通道没有这种保证;

有缓冲的channel创建格式：

make(chan Type, capacity)

如果给定了一个缓冲区容量, 通道就是异步的; 只要缓冲区有未使用空间用于发送数据, 或还包含可以接收的数据, 那么其通信就会无阻塞地进行;

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

    //内置函数 len 返回未被读取的缓冲元素数量， cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d\\n", len(c), cap(c))

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

        for i := 0; i < 3; i++ {
            c <- i
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\\n", i, len(c), cap(c))
        }
    }()

    time.Sleep(2 * time.Second) //延时2s
    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据，并赋值给num
        fmt.Println("num = ", num)
    }
    fmt.Println("main协程结束")
}

结果:

lan(c)=0, cap(c)=3
子协程正在运行[0]: len(c)=0, cap(c)=3
子协程正在运行[1]: len(c)=1, cap(c)=3
子协程正在运行[2]: len(c)=2, cap(c)=3
子协程结束
num = 0
num = 1
num = 2
main协程结束

4. 关闭channel

如果发送者知道, 没有更多的值需要发送到channel的话, 那么让接收者也能及时知道没有多余的值可接收将是有用的, 因为接收者可以停止不必要的接收等待; 这可以通过内置的close()函数来关闭channel实现;

package main

import (
    "fmt"
)

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

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 if data, ok := <-c; ok 那一行
        close(c)
    }()

    for {
        //ok为true说明channel没有关闭，为false说明管道已经关闭
        if data, ok := <-c; ok {
            fmt.Println(data)
        } else {
            break
        }
    }

    fmt.Println("Finished")
}

结果:

0
1
2
3
4
Finished

ps:

• channel不像文件一样需要经常去关闭, 只有当你确实没有任何发送数据了, 或者你想显式的结束range循环之类的, 才去关闭channel;
• 关闭channel后, 无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值);
• 关闭channel后, 可以继续从channel接收数据;
• 对于nil channel, 无论收发都会被阻塞;

可以使用 range 来迭代不断操作channel

package main

import (
    "fmt"
)

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

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 for data := range c 那一行
        close(c)
    }()

    for data := range c {
        fmt.Println(data)
    }
    fmt.Println("Finished")
}

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 转换为普通 channel
d1 := (chan int)(send) //cannot convert send (type chan<- int) to type chan int
d2 := (chan int)(recv) //cannot convert recv (type <-chan int) to type chan int

//   chan<- //只写
func counter(out chan<- int) {
    defer close(out)
    for i := 0; i < 5; i++ {
        out <- i //如果对方不读 会阻塞
    }
}

//   <-chan //只读
func printer(in <-chan int) {
    for num := range in {
        fmt.Println(num)
    }
}

func main() {
    c := make(chan int) //   chan   //读写

    go counter(c) //生产者
    printer(c)    //消费者

    fmt.Println("done")
}

6. 生产者消费者模型:

单向channel最典型的应用是“生产者消费者模型”
所谓生产者消费者模型: 某个模块(函数等)负责产生数据, 这些数据由另一个模块来负责处理(此处的模块是广义的, 可以是类、函数、协程、线程、进程等); 产生数据的模块, 就形象地称为生产者; 而处理数据的模块, 就称为消费者;
单单抽象出生产者和消费者, 还够不上是生产者／消费者模型; 该模式还需要有一个缓冲区处于生产者和消费者之间, 作为一个中介; 生产者把数据放入缓冲区, 而消费者从缓冲区取出数据; 大概的结构如下图:

缓冲区的好处大概如下:

• 解耦:
  • 假设生产者和消费者分别是两个类; 如果让生产者直接调用消费者的某个方法, 那么生产者对于消费者就会产生依赖(也就是耦合); 将来如果消费者的代码发生变化, 可能会直接影响到生产者; 而如果两者都依赖于某个缓冲区, 两者之间不直接依赖, 耦合度也就相应降低了;
• 处理并发:
  • 生产者直接调用消费者的某个方法, 还有另一个弊端; 由于函数调用是同步的(或者叫阻塞的), 在消费者的方法没有返回之前, 生产者只好一直等在那边; 万一消费者处理数据很慢, 生产者只能无端浪费时间;
  • 使用了生产者／消费者模式之后, 生产者和消费者可以是两个独立的并发主体; 生产者把制造出来的数据往缓冲区一丢, 就可以再去生产下一个数据; 基本上不用依赖消费者的处理速度;
  • 其实最当初这个生产者消费者模式, 主要就是用来处理并发问题的;
• 缓存:
  • 如果生产者制造数据的速度时快时慢, 缓冲区的好处就体现出来了; 当数据制造快的时候, 消费者来不及处理, 未处理的数据可以暂时存在缓冲区中; 等生产者的制造速度慢下来, 消费者再慢慢处理掉;

例子:

package main

import "fmt"

// 此通道只能写，不能读。
func producer(out chan<- int)  {
   for i:= 0; i < 10; i++ {
      out <- i*i          		// 将 i*i 结果写入到只写channel
   }
   close(out)
}

// 此通道只能读，不能写
func consumer(in <-chan int)  {
   for num :=以上是关于golang学习九:Go并发编程的主要内容，如果未能解决你的问题，请参考以下文章
 
 Go语言学习之旅--并发编程
 Go语言学习之旅--并发编程
 Go语言学习之旅--并发编程
 golang 并发编程之生产者消费者
 Go语言自学系列 | golang并发编程之Timer
 Go语言自学系列 | golang并发编程之协程