瞅一眼就会使用GO的并发编程分享

[TOC]

GO的并发编程分享

以前咱们分享了网络编程，今天咱们来看看GO的并发编程分享，咱们先来看看他是个啥

啥是并发编程呢？

指在一台处理器上同时处理多个任务

此处说的同时，可不是同一个时间一块儿手拉手作同一件事情

并发是在同一实体上的多个事件，而这个事件在同一时间间隔发生的，同一个时间段，有多个任务执行，但是同一个时间点，只有一个任务在执行

为啥要有并发编程？

随着互联网的普及，互联网用户人数原来越多，这对系统的性能带来了巨大的挑战。

咱们要经过各类方式来高效利用硬件的性能（压榨），从而提升系统的性能进而提高用户体验，提高团队或者企业的竞争力。

并发是为了解决什么问题？目的是啥？

是充分的利用好处理器的每个核，以达到最高的处理性能，尽量的运用好每一块砖

但是因为如今咱们使用的CPU，内存，IO三者之间速度不尽相同

咱们为了提升系统性能，计算机系统会将这三者速度进行平衡，以达到最优的效果，都有以下措施：

• 操做系统增长了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差别；
• CPU 增长了缓存，以均衡与内存的速度差别；
• 编译程序优化指令执行次序，使得缓存可以获得更加合理地利用。

说到进程和线程，他们都是干啥的呢，我们顺带说一下？

• 进程是程序在操做系统中的一次执行过程

是 系统进行资源分配和调度的一个独立单位。

• 线程是进程的一个执行实体

是 CPU 调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。

• 一个进程能够建立和撤销多个线程， 而且同一个进程中的多个线程之间能够并发执行。

讲到并发编程不得不说并发和并行有啥区别？是否是老是有小伙伴弄不清楚他们究竟是啥区别，好像同样，又好像不同

并发和并行的区别

一言蔽之，区别以下：

并发

多线程程序在一个核的 CPU 上运行

并行

多线程程序在多个核的 CPU 上运行

并发就像多个小伙伴跑接力，同一个时间点只会有一个小伙伴在跑，互相有影响

并行就像是多个小伙伴同一个起点一块儿跑，互不干扰

咱们须要记住一点，再强调一波：

并发不是并行

并发主要由切换时间片来实现"同时"运行

并行则是直接利用多核实现多线程的运行，

在 GO 能够设置使用核数，以发挥多核计算机的能力，不过设置核数都是依赖于硬件的

那么，讲到GO的并发编程，就必须上咱们的主角，那就是协程

协程 goroutine 是啥？

协程是一种程序组件

是由子例程（过程、函数、例程、方法、子程序）的概念泛化而来的

子例程只有一个入口点且只返回一次，而协程容许多个入口点，能够在指定位置挂起和恢复执行。

协程和线程分别有啥特色嘞

• 协程

独立的栈空间，共享堆空间，调度由用户本身控制

本质上有点相似于用户级线程，这些用户级线程的调度也是本身实现的。

• 线程

一个线程上能够跑多个协程，协程是轻量级的线程。

GO 高并发的缘由是啥？

• goroutine 奉行经过通讯来共享内存
• 每一个一个GO的实例有4~5KB的栈内存占用，而且因为 GO 实现机制而大幅减小的建立和销毁开销
• Golang 在语言层面上就支持协程 goroutine

GOLANG并发编程涉及哪些知识点呢？

• 基本协程的原理，实现方式，虽说，GO中使用协程很方便，能够咱们必需要知其然而值其因此然
• Goroutine 池
• runtime 包的使用
• Channel 通道
• 定时器
• 并发且安全的锁
• 原子操做
• select 多路复用
• 等等...

Goroutine的那些事

咱们写C/C++的时候，咱们必然也是要实现并发编程

咱们一般须要本身维护一个线程池，而且须要本身去包装一个又一个的任务，同时须要本身去调度线程执行任务并维护上下文切换

且作线程池的时候，咱们须要本身作一个线程管理的角色，灵活动态压缩和扩容

但是能不能有这样一种机制，咱们只须要定义多个任务，让系统去帮助咱们把这些任务分配到CPU上实现并发执行

GO里面就正好有这样的机制

goroutine 的概念相似于线程

goroutine 是由Go的运行时（runtime）调度和管理的

Go程序会智能地将 goroutine 中的任务合理地分配给每一个CPU

Go 在语言层面已经内置了调度和上下文切换的机制

写 GO 比较爽的一个地方是：

在GO里面，你不须要去本身写进程、线程、协程

咱们可使用 goroutine 包

如何使用 goroutine ？

咱们须要让某个任务并发执行的时候，只须要把这个任务包装成一个函数

专门开启一个 goroutine 协程 去执行这个函数就能够了 ， GO一个协程，很方便

一个 goroutine 一定对应一个函数，能够建立多个 goroutine 去执行相同的函数，只是多个协程都是作同一个事情罢了

咱们先来使用一下协程，再来抛砖引玉，适当的分享一下

启动单个协程

func Hi() {
    fmt.Println("this is Hi Goroutine!")
}
func main() {
    Hi()
    fmt.Println("main goroutine!")
}

咱们通常调用函数是如上这个样子的，效果以下

this is Hi Goroutine!
main goroutine!

其实咱们调用协程的话，也与上述相似

咱们可使用 go 后面加上函数名字，来开辟一个协程，专门作函数须要执行的事情

func main() {
    go Hi() // 启动一个goroutine 协程 去执行 Hi 函数
    fmt.Println("main goroutine!")

实际效果咱们能够看到，程序只打印了 main goroutine!

main goroutine!

在程序启动的时候，Go 程序就会为 main() 函数建立一个默认的 goroutine 协程

当 main() 函数返回的时候，刚开辟的另一个 goroutine 协程 就结束了

全部在 main() 函数中启动的 goroutine 协程 会一同结束，老大死了，其他的傀儡也灰飞烟灭了

咱们也可让主协程等等必定子协程，待子协程处理完本身的事情，退出后，主协程再本身退出，这和咱们写C/C++的进程 和 线程的时候，相似

简单的，咱们可使用 time.sleep 函数来让主协程阻塞等待

咱们也可使用 上述提到的 使用 select{} 来达到目的

固然也有其余的方式，后续文章会慢慢的分享到

多个协程

那么多个协程又是怎么玩的呢？

咱们使用 sync.WaitGroup 来实现goroutine 协程的同步

package main

import (
    "fmt"
    "sync"
)

var myWg sync.WaitGroup

func Hi(i int) {
    // goroutine 协程 结束就 记录 -1
    defer myWg.Done()
    fmt.Println("Hello Goroutine! the ", i)
}
func main() {

    for i := 0; i < 10; i++ {
        // 启动一个goroutine 协程 就记录 +1
        myWg.Add(1)
        go Hi(i)
    }

    // 等待全部记录 的goroutine 协程 都结束
    myWg.Wait() 
}

会有以下输出，每个协程打印的数字并非按照顺序来的：

Hello Goroutine! the  9
Hello Goroutine! the  4
Hello Goroutine! the  2
Hello Goroutine! the  3
Hello Goroutine! the  6
Hello Goroutine! the  5
Hello Goroutine! the  7
Hello Goroutine! the  8
Hello Goroutine! the  1
Hello Goroutine! the  0

仍是一样的， 若是是主协程先退出，那么子协程还行继续运行吗？

毋庸置疑，主协程退出，子协程也会跟着退出

GO 中的 协程

分享以下几个点

GO中的栈是可增加的

通常都有固定的栈内存（一般为2MB），goroutine 的栈不是固定的，goroutine 的栈大小能够扩展到1GB

goroutine 是如何调度

这就不得不提 GPM

GPM是Go语言运行时（runtime）层面实现的，咱们先简单了解一下GPM分别表明啥

G

就是个 goroutine ，里面除了存放本 goroutine 信息外 还有与所在P的绑定等信息

P

Processor 管理着一组 goroutine 队列

P 里面会存储当前 goroutine 运行的上下文环境（函数指针，堆栈地址及地址边界）

P 会对本身管理的 goroutine 队列作一些调度（好比把占用CPU时间较长的 goroutine 暂停、运行后续的 goroutine）

当本身的队列消费完了就去全局队列里取，若是全局队列里也消费完了会去其余P的队列里抢任务。

M（machine）

是 Go 运行时（runtime）对操做系统内核线程的虚拟

M 与内核线程通常是一一映射的关系， 一个 groutine 最终是要放到 M上执行

这里的 P 与 M 通常也是一一对应的

P 管理着一组G 挂载在 M 上运行

当一个 G 长久阻塞在一个 M 上时，runtime 会新建一个M，

阻塞 G 所在的 P 会把其余的 G 挂载在新建的M上

这个时候，当旧的 G 阻塞完成或者认为其已经挂了的话，就会回收旧的 M

还有一点

P 的个数是经过 runtime.GOMAXPROCS 设定（最大256），这个数字也依赖于本身的硬件，在并发量大的时候会增长一些 P 和 M ，但不会太多

总结

• 分享了并发和并行
• 分享了GO 的并发，协程的简单使用
• 简单分享了GO可伸缩扩展的栈内存

关于GO的并发编程知识点涉及面多，对于他的调度原理，真实感兴趣的话，能够看上述提到的GO并发涉及的知识点，一点一点的深刻下去，今天就到这里，大致了解GO协程的使用

欢迎点赞，关注，收藏

朋友们，你的支持和鼓励，是我坚持分享，提升质量的动力

好了，本次就到这里，下一次GO的锁和原子操做分享

技术是开放的，咱们的心态，更应是开放的。拥抱变化，向阳而生，努力向前行。

我是小魔童哪吒，欢迎点赞关注收藏，下次见~