eraft 精解课程

MIT 分布式系统（二）Go 语言基础知识 #

Go语言优点

首先 Go 是一门开源的语言，他出生名门 Google，社区有强有力的顶级技术人员支撑。它最开始的设计者是 Rob Pike，Robert Griesemer，Ken Thompson。 你可以在这个页面找到他们的资料 https://golang.design/history/ 其中 Ken Thompson 是 UNIX 系统的发明者。 Go 语言对于初学者很友好，很容易在短时间内快速上手，你可以通过这个网站上提供的代码示例快速的入门 Go 语言：https://gobyexample.com。 作为多核时代的语言，Go 语言在设计之初就对并发编程有很多内置的支持，提供的及其健壮的相关标准库。利用它，我们可以快速的编写出高并发的应用程序。 最后，国内外很多大厂都在使用 Go 语言，它有一个强大的社区，全世界优秀的技术人员开发了丰富的工具生态，有很多脚手架帮你快速的构建应用程序。

切片

切片是一个数组的一段，它基于数组构建，并提供了更多丰富的数据操作功能，提供开发者灵活和便利的操作数组结构。 在 Go 语言内部，切片只是对底层数组数据结构的引用。接下来我们将熟悉如何创建和使用切片，并了解它底层是怎么工作的。

使用字面量列表创建

var s = []int{3, 5, 7, 9, 11, 13, 17}

从已有数组创建切片

// Obtaining a slice from an array `a`
a[low:high]

package main

import "fmt"

func main() {

    var a = [5]string{"Alpha", "Beta", "Gamma", "Delta", "Epsilon"}

    // Creating a slice from the array
    var s []string = a[1:4]

    fmt.Println("Array a = ", a)        

    fmt.Println("Slice s = ", s)       

}       

// output      


Array a =  [Alpha Beta Gamma Delta Epsilon]       

Slice s =  [Beta Gamma Delta]       
        

修改切片中的元素

package main

import "fmt"


func main() {

	a := [7]string{"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"}


	slice1 := a[1:]

	slice2 := a[3:]


	fmt.Println("------- Before Modifications -------")

	fmt.Println("a  = ", a)

	fmt.Println("slice1 = ", slice1)

	fmt.Println("slice2 = ", slice2)


	slice1[0] = "TUE"

	slice1[1] = "WED"

	slice1[2] = "THU"


	slice2[1] = "FRIDAY"


	fmt.Println("\n-------- After Modifications --------")

	fmt.Println("a  = ", a)

	fmt.Println("slice1 = ", slice1)

	fmt.Println("slice2 = ", slice2)

}


// Output


------- Before Modifications -------

a  =  [Mon Tue Wed Thu Fri Sat Sun]

slice1 =  [Tue Wed Thu Fri Sat Sun]

slice2 =  [Thu Fri Sat Sun]


type: post

-------- After Modifications --------

a  =  [Mon TUE WED THU FRIDAY Sat Sun]

slice1 =  [TUE WED THU FRIDAY Sat Sun]

slice2 =  [THU FRIDAY Sat Sun]

例如上面这个示例，slice2 的修改操作在 slice1 中是能被看到的, slice1 的修改在 slice2 也能被看到。

切片底层结构

一个切片由三个部分组成，如图
1.一个指向底层数组的指针 Ptr
2.切片所包含数组段的长度 Len
3.切片的容量 Cap

package main

import "fmt"


func main() {

	a := [6]int{10, 20, 30, 40, 50, 60}

	s := a[1:4]


	fmt.Printf("s = %v, len = %d, cap = %d\n", s, len(s), cap(s))

}


// output

s = [20 30 40], len = 3, cap = 5

Goruntine

package main
    

import (

	"fmt"

	"time"

)


func say(s string) {

	for i := 0; i < 5; i++ {

		time.Sleep(100 * time.Millisecond)

		fmt.Println(s)

	}

}


func main() {

	go say("world")

	say("hello")

}


// output


hello

world

hello

world

hello

world

world

hello

hello

我们可以看到主线程中 say("hello") 和 goruntine 的 say("world") 在交替的输出，它们在同时的运行，在其他语言做这个事情先要创建线程，然后绑定相关的执行函数，而 Go 语言直接把并发设计到了编译器语言支持层面，用 go 关键字就可以轻松地创建轻量级的线程。

调度器

调度器的设计决策

func main() {

    var wg sync.WaitGroup

    wg.Add(11)

    for i := 0; i <= 10; i++ {

        go func(i int) {

          defer wg.Done()

          fmt.Printf("loop i is - %d\n", i)

        }(i)

    }

    wg.Wait()

    fmt.Println("Hello, Welcome to Go")

}



// output


loop i is - 0

loop i is - 4

loop i is - 1

loop i is - 2

loop i is - 3

loop i is - 8

loop i is - 7

loop i is - 9

loop i is - 5

loop i is - 10

loop i is - 6

Hello, Welcome to Go

这个程序创建了 11 个 Goruntine，对于这个输出结果，我们可能会问：
这 11 个 Goruntine 是如何并行运行的？
它们运行有没有特别的顺序？
要回答这两个问题，我们需要思考:
如何将多个 Goruntine 分配到我们有限个数的 CPU 核心的机器上运行的多个 OS 线程上?
为了公平的让这些 Goruntine 获得 CPU 资源，这些 Goruntine 应该以什么的顺序在这多个 CPU 核心上运行?

Go 调度器的模型介绍

为了解决上面的调度问题，Go 语言设计了图 d 中的调度器模型：
Go 语言使用协程调度被称为 GMP 模型，其中：
G: 代表一个 Goruntine，是我们使用 go 关键字创建出来的可以并行运行的代码块。
M: 代表一个操作系统线程
P: 代表逻辑处理器
我们看到上图中由两个 P 处理核心运行时调度正在调度执行 8 个 Goruntine。
图中我们还看到了有两种类型的队列：
本地队列 (Local Run Queue): 存放等待运行的 G，这个队列存储的数量有限，一般不能超过 256个，当用户新建 Goruntine 时，如果这个队列满了，Go 运行时会将一半的 G 移动到全局队列中。
全局队列 (Global Queue): 存放等待运行的 G，其他的本地队列满了，会移动 G 过来。

Go 调度器的工作流程

跟踪 Go 调度器工作流程

package main


import (

	"sync"

	"time"

)


func main() {

	var wg sync.WaitGroup

	wg.Add(10)

	for i := 0; i < 10; i++ {

		go work(&wg)

	}


	wg.Wait()


	// Wait to see the global run queue deplete.

	time.Sleep(3 * time.Second)

}


func work(wg *sync.WaitGroup) {

	time.Sleep(time.Second)


	var counter int

	for i := 0; i < 1e10; i++ {

		counter++

	}


	wg.Done()

}

colin@book % GOMAXPROCS=2 GODEBUG=schedtrace=1000 ./go_demo

SCHED 0ms: gomaxprocs=2 idleprocs=1 threads=4 spinningthreads=0 idlethreads=1 runqueue=0 [0 0]

SCHED 1009ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=0 [8 0]

SCHED 2009ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=2 [3 3]

SCHED 3016ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=2 [3 3]

SCHED 4017ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=7 [0 1]

SCHED 5027ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=5 [0 3]

SCHED 6031ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=3 [2 3]

SCHED 7037ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=5 [1 2]

SCHED 8045ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=4 [2 2]

SCHED 9052ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=8 [0 0]

SCHED 10065ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=4 [0 4]

SCHED 11069ms: gomaxprocs=2 idleprocs=0 threads=4 spinningthreads=0 idlethreads=1 runqueue=4 [1 3]

了解更多调度器原理

内存管理

内存管理架构概览

捐赠

整理这本书耗费了我们大量的时间和精力。如果你觉得有帮助，一瓶矿泉水的价格支持我们继续输出优质的分布式存储知识体系，2.99¥，感谢大家的支持。

遵循MIT协议开源。

感谢 「赫蹏」 提供如此优秀的中文排版系统