关于golang:瞅一眼就会使用GO的并发编程分享

[TOC]

GO的并发编程分享

之前咱们分享了网络编程,明天咱们来看看GO的并发编程分享,咱们先来看看他是个啥

啥是并发编程呢?

指在一台处理器上同时解决多个工作

此处说的同时,可不是同一个工夫一起手拉手做同一件事件

并发是在同一实体上的多个事件,而这个事件在同一时间距离产生的,同一个时间段,有多个工作执行,可是同一个工夫点,只有一个工作在执行

为啥要有并发编程?

随着互联网的遍及,互联网用户人数原来越多,这对系统的性能带来了微小的挑战。

咱们要通过各种形式来高效利用硬件的性能(压迫),从而进步零碎的性能进而晋升用户体验,晋升团队或者企业的竞争力。

并发是为了解决什么问题?目标是啥?

充沛的利用好处理器的每一个核,以达到最高的解决性能,尽可能的使用好每一块砖

可是因为当初咱们应用的CPU,内存,IO三者之间速度不尽相同

咱们为了进步零碎性能,计算机系统会将这三者速度进行均衡,以达到最优的成果,都有如下措施:

  • 操作系统减少了过程线程,以分时复用 CPU,进而平衡 CPUI/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的锁和原子操作分享

技术是凋谢的,咱们的心态,更应是凋谢的。拥抱变动,背阴而生,致力向前行。

我是小魔童哪吒,欢送点赞关注珍藏,下次见~

【腾讯云】云产品限时秒杀,爆款1核2G云服务器,首年99元

阿里云限时活动-2核2G-5M带宽-40-100G SSD服务器,特惠价86元/年(原价724元/年,限时99元续购三次),速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

You may also like...

发表评论

邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据