runtime包

尽管 Go 编译器产生的是本地可执行代码，这些代码仍旧运行在 Go 的 runtime（这部分的代码可以在 runtime 包中找到）当中。这个 runtime 类似 Java 和 .NET 语言所用到的虚拟机，它负责管理包括内存分配、垃圾回收、栈处理、goroutine、channel、切片（slice）、map 和反射（reflection）等等。

常用函数

runtime 调度器是个非常有用的东西，关于 runtime 包几个方法:

• NumCPU：返回当前系统的 CPU 核数量

• GOMAXPROCS：设置最大的可同时使用的 CPU 核数

  通过runtime.GOMAXPROCS函数，应用程序何以在运行期间设置运行时系统中得P最大数量。但这会引起“Stop the World”。所以，应在应用程序最早的调用。并且最好是在运行Go程序之前设置好操作程序的环境变量GOMAXPROCS，而不是在程序中调用runtime.GOMAXPROCS函数。

  无论我们传递给函数的整数值是什么值，运行时系统的P最大值总会在1~256之间。

go1.8后，默认让程序运行在多个核上,可以不用设置了
go1.8前，还是要设置一下，可以更高效的利益cpu

• Gosched：让当前线程让出 cpu 以让其它线程运行,它不会挂起当前线程，因此当前线程未来会继续执行

  这个函数的作用是让当前 goroutine 让出 CPU，当一个 goroutine 发生阻塞，Go 会自动地把与该 goroutine 处于同一系统线程的其他 goroutine 转移到另一个系统线程上去，以使这些 goroutine 不阻塞。

• Goexit：退出当前 goroutine(但是defer语句会照常执行)

• NumGoroutine：返回正在执行和排队的任务总数

  runtime.NumGoroutine函数在被调用后，会返回系统中的处于特定状态的Goroutine的数量。这里的特指是指Grunnable\Gruning\Gsyscall\Gwaition。处于这些状态的Groutine即被看做是活跃的或者说正在被调度。

  注意：垃圾回收所在Groutine的状态也处于这个范围内的话，也会被纳入该计数器。

• GOOS：目标操作系统

• runtime.GC:会让运行时系统进行一次强制性的垃圾收集

  1. 强制的垃圾回收：不管怎样，都要进行的垃圾回收。
  2. 非强制的垃圾回收：只会在一定条件下进行的垃圾回收（即运行时，系统自上次垃圾回收之后新申请的堆内存的单元（也成为单元增量）达到指定的数值）。

• GOROOT :获取goroot目录

• GOOS : 查看目标操作系统
  很多时候，我们会根据平台的不同实现不同的操作，就而已用GOOS了：

示例代码

1. 获取goroot和os：

 //获取goroot目录：fmt.Println("GOROOT-->",runtime.GOROOT())//获取操作系统fmt.Println("os/platform-->",runtime.GOOS)  

GOROOT--> C:\Users\19393\sdk\go1.20.4
os/platform--> windows

2. 获取CPU数量，和设置CPU数量：

func init(){//1.获取逻辑cpu的数量fmt.Println("逻辑CPU的核数：",runtime.NumCPU())	//16//2.设置go程序执行的最大的：[1,256]n := runtime.GOMAXPROCS(runtime.NumCPU())	fmt.Println(n)	//16
}

3. Gosched()：

func main() {go func() {for i := 0; i < 5; i++ {fmt.Println("goroutine")}}()for i := 0; i < 4; i++ {//让出时间片，先让别的协议执行，它执行完，再回来执行此协程runtime.Gosched()fmt.Println("main")}
}

goroutine
goroutine
goroutine
goroutine
goroutine
main
main
main
main

4. Goexit的使用（终止协程）

package mainimport ("fmt""runtime""time"
)func main() {//创建新建的协程go func() {fmt.Println("goroutine开始")//调用了别的函数fun()fmt.Println("goroutine结束")}() //别忘了()//睡一会儿，不让主协程结束time.Sleep(3 * time.Second)
}func fun() {defer fmt.Println("defer")//return //终止此函数runtime.Goexit() //终止所在的协程fmt.Println("fun函数")
}

goroutine开始
defer

临界资源

临界资源: 指并发环境中多个进程/线程/协程共享的资源。

但是在并发编程中对临界资源的处理不当， 往往会导致数据不一致的问题。

示例代码：

package mainimport ("fmt""time"
)func main()  {a := 1go func() {a = 2fmt.Println("子goroutine",a)}()a = 3time.Sleep(1)fmt.Println("main goroutine",a)
}

子goroutine 2
main goroutine 2

能够发现一处被多个goroutine共享的数据a。

临界资源安全问题

并发本身并不复杂，但是因为有了资源竞争的问题，就使得我们开发出好的并发程序变得复杂起来，因为会引起很多莫名其妙的问题。

如果多个goroutine在访问同一个数据资源的时候，其中一个线程修改了数据，那么这个数值就被修改了，对于其他的goroutine来讲，这个数值可能是不对的。

举个例子，我们通过并发来实现火车站售票这个程序。一共有10张票，4个售票口同时出售。

我们先来看一下示例代码：

package mainimport ("fmt""math/rand""time"
)// 全局变量
var ticket = 10 //func main() {/*4个goroutine，模拟4个售票口，4个子程序操作同一个共享数据。*/go saleTickets("售票口1") // g1,10go saleTickets("售票口2") // g2,10go saleTickets("售票口3") //g3,10go saleTickets("售票口4") //g4,10time.Sleep(5 * time.Second)
}func saleTickets(name string) {rand.Seed(time.Now().UnixNano())for { //ticket=1if ticket > 0 { //g1,g3,g2,g4//睡眠time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)// g1 ,g3, g2,g4fmt.Println(name, "售出：", ticket) ticket--                         } else {fmt.Println(name, "售罄，没有票了。。")break}}
}

运行结果：

售票口4 售出： 10
售票口1 售出： 10
售票口3 售出： 10
售票口2 售出： 10
售票口1 售出： 6
售票口1 售出： 5
售票口2 售出： 4
售票口4 售出： 3
售票口4 售出： 2
售票口1 售出： 1
售票口1 售罄，没有票了。。
售票口3 售出： 0
售票口3 售罄，没有票了。。
售票口4 售出： -1
售票口4 售罄，没有票了。。
售票口2 售出： -2
售票口2 售罄，没有票了。。

我们为了更好的观察临界资源问题，每个goroutine先睡眠一个随机数，然后再售票，我们发现程序的运行结果，还可以卖出编号为负数的票。

分析：

我们的卖票逻辑是先判断票数的编号是否为负数，如果大于0，然后我们就进行卖票，只不过在卖票钱先睡眠，然后再卖，假如说此时已经卖票到只剩最后1张了，某一个goroutine持有了CPU的时间片，那么它再片段是否有票的时候，条件是成立的，所以它可以卖票编号为1的最后一张票。但是因为它在卖之前，先睡眠了，那么其他的goroutine就会持有CPU的时间片，而此时这张票还没有被卖出，那么第二个goroutine再判断是否有票的时候，条件也是成立的，那么它可以卖出这张票，然而它也进入了睡眠。其他的第三个第四个goroutine都是这样的逻辑，当某个goroutine醒来的时候，不会再判断是否有票，而是直接售出，这样就卖出最后一张票了，然而其他的goroutine醒来的时候，就会陆续卖出了第0张，-1张，-2张。

这就是临界资源的不安全问题。某一个goroutine在访问某个数据资源的时候，按照数值，已经判断好了条件，然后又被其他的goroutine抢占了资源，并修改了数值，等这个goroutine再继续访问这个数据的时候，数值已经不对了。

临界资源安全问题的解决

要想解决临界资源安全的问题，很多编程语言的解决方案都是同步。通过上锁的方式，某一时间段，只能允许一个goroutine来访问这个共享数据，当前goroutine访问完毕，解锁后，其他的goroutine才能来访问。

我们可以借助于sync包下的锁操作。

示例代码：

package mainimport ("fmt""math/rand""time""sync"
)//全局变量
var ticket = 10 // 10张票var wg sync.WaitGroup
var matex sync.Mutex // 创建锁头func main() {/*4个goroutine，模拟4个售票口，4个子程序操作同一个共享数据。*/wg.Add(4)go saleTickets("售票口1") // g1,100go saleTickets("售票口2") // g2,100go saleTickets("售票口3") //g3,100go saleTickets("售票口4") //g4,100wg.Wait()              // main要等待。。。//time.Sleep(5*time.Second)
}func saleTickets(name string) {rand.Seed(time.Now().UnixNano())defer wg.Done()//for i:=1;i<=100;i++{//	fmt.Println(name,"售出：",i)//}for { //ticket=1matex.Lock()if ticket > 0 { //g1,g3,g2,g4//睡眠time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)// g1 ,g3, g2,g4fmt.Println(name, "售出：", ticket) // 1 , 0, -1 , -2ticket--                         //0 , -1 ,-2 , -3} else {matex.Unlock() //解锁fmt.Println(name, "售罄，没有票了。。")break}matex.Unlock() //解锁}
}

运行结果：

售票口1 售出： 10
售票口1 售出： 9
售票口4 售出： 8
售票口3 售出： 7
售票口2 售出： 6
售票口1 售出： 5
售票口4 售出： 4
售票口3 售出： 3
售票口2 售出： 2
售票口1 售出： 1
售票口4 售罄，没有票了。。
售票口1 售罄，没有票了。。
售票口3 售罄，没有票了。。
售票口2 售罄，没有票了。。

最后

在Go的并发编程中有一句很经典的话：不要以共享内存的方式去通信，而要以通信的方式去共享内存。

在Go语言中并不鼓励用锁保护共享状态的方式在不同的Goroutine中分享信息(以共享内存的方式去通信)。而是鼓励通过channel将共享状态或共享状态的变化在各个Goroutine之间传递（以通信的方式去共享内存），这样同样能像用锁一样保证在同一的时间只有一个Goroutine访问共享状态。

当然，在主流的编程语言中为了保证多线程之间共享数据安全性和一致性，都会提供一套基本的同步工具集，如锁，条件变量，原子操作等等。Go语言标准库也毫不意外的提供了这些同步机制，使用方式也和其他语言也差不多。