go语言原本 go语言的

Golang的调度模型

Go有四大核心模块,基本全部体现在runtime,有调度系统、GC、goroutine、channel,那么深入理解其中的精髓可以帮助我们理解Go这一门语言!

成都创新互联公司长期为1000+客户提供的网站建设服务,团队从业经验10年,关注不同地域、不同群体,并针对不同对象提供差异化的产品和服务;打造开放共赢平台,与合作伙伴共同营造健康的互联网生态环境。为唐山企业提供专业的网站建设、网站制作,唐山网站改版等技术服务。拥有十年丰富建站经验和众多成功案例,为您定制开发。

参考: 调度系统设计精要

下面是我用Go语言简单写的一个调度器,大家可以看看设计思路,以及存在的问题!

1、测试条件,调度器只启动两个线程,然后一个线程主要是负责循环的添加任务,一个线程循环的去执行任务

2、测试条件,调度器启动三个线程,然后两个线程去执行任务,一个添加任务

3、继续测试,启动十个线程,一个添加任务,九个执行任务

4、我们添加一些阻塞的任务

执行可以看到完全不可用

1、 可以看到随着M的不断的增加,可以发现执行任务的数量也不断的减少,原因是什么呢?有兴趣的同学可以加一个pprof可以看看,其实大量的在等待锁的过程!

2、如果我的M运行了类似于Sleep操作的方法如何解决了,我的调度器还能支撑这个量级的调度吗?

关于pprof如何使用:在代码头部加一个这个代码:

我们查看一下 go tool pprof main/prof.pporf

可以看到真正执行代码的时间只有 0.17s + 0.02s 其他时间都被阻塞掉了!

1、GM模型中的所有G都是放入到一个queue,那么导致所有的M取执行任务时都会去竞争锁,我们插入G也会去竞争锁,所以解决这种问题一般就是减少对单一资源的竞争,那就是桶化,其实就是每个线程都分配一个队列

2、GM模型中没有任务状态,只有runnable,假如任务遇到阻塞,完全可以把任务挂起再唤醒

这里其实会遇到一个问题,假如要分配很多个线程,那么此时随着线程的增加,也会造成队列的增加,其实也会造成调度器的压力,因为它需要遍历全部线程的队列去分配任务以及后续会讲到的窃取任务!

因为我们知道CPU的最大并行度其实取决于CPU的核数,也就是我们没必要为每个线程都去分配一个队列,因为就算是给他们分配了,他们自己去那执行调度,其实也会出现大量阻塞,原因就是CPU调度不过来这些线程!

Go里面是只分配了CPU个数的队列,这里就是P这个概念,你可以理解为P其实是真正的资源分配器,M很轻只是执行程序,所有的资源内存都维护在P上!M只有绑定P才能执行任务(强制的)!

这样做的好处:

1、首先调度程序其实就是调度不同状态的任务,go里面为Go标记了不同的状态,其实大概就是分为:runnable,running,block等,所以如何充分调度不同状态的G成了问题,那么关于阻塞的G如何解决,其实可以很好的解决G调度的问题!

上面这些情况其实就分为:

2、用户态阻塞,一般Go里面依靠 gopark 函数去实现,大体的代码逻辑基本上和go的调度绑定死了

源码在:

3、其实对于netpool 这种nio模型,其实内核调用是非阻塞的,所以go开辟了一个网络轮训器队列,来存放这些被阻塞的g,等待内核被唤醒!那么什么时候会被唤醒了,其实就是需要等待调度器去调度了!

4、如果是内核态阻塞了(内核态阻塞一般都会将线程挂起,线程需要等待被唤醒),我们此时P只能放弃此线程的权利,然后再找一个新的线程去运行P!

关于着新线程:找有没有idle的线程,没有就会创建一个新的线程!

关于当内核被唤醒后的操作:因为GPM模型所以需要找到个P绑定,所以G会去尝试找一个可用的P,如果没有可用的P,G会标记为runnable放到全局队列中!

5、其实了解上面大致其实就了解了Go的基本调度模型

答案文章里慢慢品味!

如果某个 G 执行时间过长,其他的 G 如何才能被正常的调度? 这便涉及到有关调度的两个理念:协作式调度与抢占式调度。协作式和抢占式这两个理念解释起来很简单: 协作式调度依靠被调度方主动弃权;抢占式调度则依靠调度器强制将被调度方被动中断。

例如下面的代码,我本地的版本是 go1.13.5

执行: GOMAXPROCS=1 配置全局只能有一个P

可以看到main函数无法执行!也就是那个go 空转抢占了整个程序

备注:

但是假如我换为用 1.14+版本执行,有兴趣的话可以使用我的docker镜像,直接可以拉取: fanhaodong/golang:1.15.11 和 fanhaodong/golang:1.13.5

首先我们知道G/M/P,G可能和M也可能和P解除绑定,那么关于数据变量放在哪哇!其实这个就是逃逸分析!

输出可以看到其实没有发生逃逸,那是因为 demo被拷贝它自己的栈空间内

备注:

-gcflags"-N -l -m" 其中 -N禁用优化-l禁止内联优化,-m打印逃逸信息

那么继续改成这个

可以看到发现 demo对象其实被逃逸到了堆上!这就是不会出现类似于G如果被别的M执行,其实不会出现内存分配位置的问题!

所以可以看到demo其实是copy到了堆上!这就是g逃逸的问题,和for循环一样的

执行可以发现,其实x已经逃逸到了堆上,所以你所有的g都引用的一个对象,如何解决了

如何解决了,其实很简单

也谈goroutine调度器

图解Go运行时调度器

Go语言回顾:从Go 1.0到Go 1.13

Go语言原本

调度系统设计精要

Scalable Go Scheduler Design Doc

为什么许多原本的 Java 项目都试图用 go 进行重写开源?

项目推倒重构是项目开发大忌,一方面我们要尽量避免做项目推倒重构,尽量在前期就规划好,另一方面,我们又希望项目能常做小重构,这对项目可持续性开发是很有帮助的。而语言的重构,把Java项目用Go语言重写一遍,无疑是一次重大的推倒重来。

一、Go语言的优势在哪里

Go语言领先于Java的最大优势,就在于快。Go语言会被编译成机器代码,直接执行;Java语言则使用JVM运行其代码,这比Go语言要慢了很多。另外,Java语言的内存管理,相比于Go语言,也复杂得多,而内存管理,不管对于程序运行,还是对程序员的开发,都极为重要。最后,Go语言没有引用只有指针,这比Java语言处处引用,又领先了一个身位。

二、Go语言为什么更适合开源

开源,也就是开放源代码,最大的好处在于,可以利用全世界的程序员资源,来帮助你完善你的产品,开发新需求,或者修复产品BUG。这对产品的可持续发展,是非常有帮助的,很多企业纷纷将自己的产品开源,其实就是这个道理。而Go语言更易学,更易避错,更易阅读等特点,就决定了它更适合用来做开源项目。

三、Java语言的优势

Java语言是目前软件开发中使用率最广泛,也是最重要的程序之一,它的地位,绝对不是目前Go语言可以比拟的。Java在WEB应用的开发中,有着很重要的地位。但是,Java语言相对复杂的并发设计,相当庞大的项目体系,使其在开发、测试阶段都略为复杂,在某些方面已经逐步落后于其他语言。

go语言数组,切片和字典的区别和联系

、数组 

与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列。

(1)数组的创建。

数组有3种创建方式:[length]Type 、[N]Type{value1, value2, ... , valueN}、[...]Type{value1, value2, ... , valueN} 如下:

复制代码代码如下:

func test5() {

var iarray1 [5]int32

var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5}

iarray3 := [5]int32{1, 2, 3, 4, 5}

iarray4 := [5]int32{6, 7, 8, 9, 10}

iarray5 := [...]int32{11, 12, 13, 14, 15}

iarray6 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}}

fmt.Println(iarray1)

fmt.Println(iarray2)

fmt.Println(iarray3)

fmt.Println(iarray4)

fmt.Println(iarray5)

fmt.Println(iarray6)

}

结果:

[0 0 0 0 0]

[1 2 3 4 5]

[1 2 3 4 5]

[6 7 8 9 10]

[11 12 13 14 15]

[[1 0 0 0] [1 2 0 0] [1 2 3 0] [0 0 0 0]]

我们看数组 iarray1,只声明,并未赋值,Go语言帮我们自动赋值为0。再看 iarray2 和 iarray3 ,我们可以看到,Go语言的声明,可以表明类型,也可以不表明类型,var iarray3 = [5]int32{1, 2, 3, 4, 5} 也是完全没问题的。

(2)数组的容量和长度是一样的。cap() 函数和 len() 函数均输出数组的容量(即长度)。如:

复制代码代码如下:

func test6() {

iarray4 := [5]int32{6, 7, 8, 9, 10}

fmt.Println(len(iarray4))

fmt.Println(cap(iarray4))

}

输出都是5。

(3)使用:

复制代码代码如下:

func test7() {

iarray7 := [5]string{"aaa", `bb`, "可以啦", "叫我说什么好", "()"}

fmt.Println(iarray7)

for i := range iarray7 {

fmt.Println(iarray7[i])

}

}

二、切片

Go语言中,切片是长度可变、容量固定的相同的元素序列。Go语言的切片本质是一个数组。容量固定是因为数组的长度是固定的,切片的容量即隐藏数组的长度。长度可变指的是在数组长度的范围内可变。

(1)切片的创建。

切片的创建有4种方式:

1)make ( []Type ,length, capacity )

2) make ( []Type, length)

3) []Type{}

4) []Type{value1 , value2 , ... , valueN }

从3)、4)可见,创建切片跟创建数组唯一的区别在于 Type 前的“ [] ”中是否有数字,为空,则代表切片,否则则代表数组。因为切片是长度可变的。如下是创建切片的示例:

复制代码代码如下:

func test8() {

slice1 := make([]int32, 5, 8)

slice2 := make([]int32, 9)

slice3 := []int32{}

slice4 := []int32{1, 2, 3, 4, 5}

fmt.Println(slice1)

fmt.Println(slice2)

fmt.Println(slice3)

fmt.Println(slice4)

}

输出为:

[0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[]

[1 2 3 4 5]

如上,创造了4个切片,3个空切片,一个有值的切片。

(2)切片与隐藏数组:

一个切片是一个隐藏数组的引用,并且对于该切片的切片也引用同一个数组。如下示例,创建了一个切片slice0,并根据这个切片创建了2个切片 slice1 和 slice2:

复制代码代码如下:

func test9() {

slice0 := []string{"a", "b", "c", "d", "e"}

slice1 := slice0[2 : len(slice0)-1]

slice2 := slice0[:3]

fmt.Println(slice0, slice1, slice2)

slice2[2] = "8"

fmt.Println(slice0, slice1, slice2)

}

输出为:

[a b c d e] [c d] [a b c]

[a b 8 d e] [8 d] [a b 8]

可见,切片slice0 、 slice1 和 slice2是同一个底层数组的引用,所以slice2改变了,其他两个都会变。

(3)遍历、修改切片:

复制代码代码如下:

func test10() {

slice0 := []string{"a", "b", "c", "d", "e"}

fmt.Println("\n~~~~~~元素遍历~~~~~~")

for _, ele := range slice0 {

fmt.Print(ele, " ")

ele = "7"

}

fmt.Println("\n~~~~~~索引遍历~~~~~~")

for index := range slice0 {

fmt.Print(slice0[index], " ")

}

fmt.Println("\n~~~~~~元素索引共同使用~~~~~~")

for index, ele := range slice0 {

fmt.Print(ele, slice0[index], " ")

}

fmt.Println("\n~~~~~~修改~~~~~~")

for index := range slice0 {

slice0[index] = "9"

}

fmt.Println(slice0)

}

如上,前三种循环使用了不同的for range循环,当for后面,range前面有2个元素时,第一个元素代表索引,第二个元素代表元素值,使用 “_” 则表示忽略,因为go语言中,未使用的值会导致编译错误。

只有一个元素时,该元素代表索引。

只有用索引才能修改元素。如在第一个遍历中,赋值ele为7,结果没有作用。因为在元素遍历中,ele是值传递,ele是该切片元素的副本,修改它不会影响原本值,而在第四个遍历——索引遍历中,修改的是该切片元素引用的值,所以可以修改。

结果为:

~~~~~~元素遍历~~~~~~

a b c d e

~~~~~~索引遍历~~~~~~

a b c d e

~~~~~~元素索引共同使用~~~~~~

aa bb cc dd ee

~~~~~~修改~~~~~~

[9 9 9 9 9]

(4)、追加、复制切片:

复制代码代码如下:

func test11() {

slice := []int32{}

fmt.Printf("slice的长度为:%d,slice为:%v\n", len(slice), slice)

slice = append(slice, 12, 11, 10, 9)

fmt.Printf("追加后,slice的长度为:%d,slice为:%v\n", len(slice), slice)

slicecp := make([]int32, (len(slice)))

fmt.Printf("slicecp的长度为:%d,slicecp为:%v\n", len(slicecp), slicecp)

copy(slicecp, slice)

fmt.Printf("复制赋值后,slicecp的长度为:%d,slicecp为:%v\n", len(slicecp), slicecp)

}

追加、复制切片,用的是内置函数append和copy,copy函数返回的是最后所复制的元素的数量。

(5)、内置函数append

内置函数append可以向一个切片后追加一个或多个同类型的其他值。如果追加的元素数量超过了原切片容量,那么最后返回的是一个全新数组中的全新切片。如果没有超过,那么最后返回的是原数组中的全新切片。无论如何,append对原切片无任何影响。如下示例:

复制代码代码如下:

func test12() {

slice := []int32{1, 2, 3, 4, 5, 6}

slice2 := slice[:2]

_ = append(slice2, 50, 60, 70, 80, 90)

fmt.Printf("slice为:%v\n", slice)

fmt.Printf("操作的切片:%v\n", slice2)

_ = append(slice2, 50, 60)

fmt.Printf("slice为:%v\n", slice)

fmt.Printf("操作的切片:%v\n", slice2)

}

如上,append方法用了2次,结果返回的结果完全不同,原因是第二次append方法追加的元素数量没有超过 slice 的容量。而无论怎样,原切片slice2都无影响。结果:

slice为:[1 2 3 4 5 6]

操作的切片:[1 2]

slice为:[1 2 50 60 5 6]

操作的切片:[1 2]


网页名称:go语言原本 go语言的
文章路径:http://pwwzsj.com/article/dodgpdj.html