runtime 包,定义了协程管理相关的 API
runtime.Gosched()
package main
import (
"fmt"
"runtime"
)
func main() {
go func() {
for i := 0; i <= 5; i++ {
fmt.Println(i)
}
}()
// 让出当前CPU给其他协程
runtime.Gosched()
fmt.Println("end...")
}
runtime.Goexit()
package main
import (
"fmt"
"runtime"
"time"
)
func show() {
for i := 0; i <= 5; i++ {
if i > 3 {
// 退出当前协程
runtime.Goexit()
}
fmt.Println(i)
}
}
func main() {
go show()
// 主协程睡眠1s
time.Sleep(time.Second)
fmt.Println("end...")
}
runtime.GOMAXPROCS()
package main
import (
"fmt"
"runtime"
"time"
)
func funcA() {
for i := 0; i < 5; i++ {
fmt.Printf("funcA: %v \n", i)
time.Sleep(time.Millisecond * 100)
}
}
func funcB() {
for i := 0; i < 5; i++ {
fmt.Printf("funcB: %v \n", i)
time.Sleep(time.Millisecond * 100)
}
}
func main() {
fmt.Printf("CPU nums: %v \n", runtime.NumCPU())
// 设置最大CPU核心数
runtime.GOMAXPROCS(1)
go funcA()
go funcB()
// 主协程睡眠1s
time.Sleep(time.Second)
fmt.Println("end...")
}
Mutex 互斥锁实现同步
sync.Mutex
package main
import (
"fmt"
"sync"
"time"
)
var count int
var wp sync.WaitGroup
var lock sync.Mutex
func add() {
defer wp.Done()
// 加锁
lock.Lock()
count++
fmt.Printf("add: %v \n", count)
time.Sleep(time.Millisecond * 10)
// 解锁
lock.Unlock()
}
func sub() {
defer wp.Done()
lock.Lock()
count--
fmt.Printf("sub: %v \n", count)
time.Sleep(time.Millisecond * 100)
lock.Unlock()
}
func main() {
for i := 0; i < 10; i++ {
wp.Add(1)
go add()
wp.Add(1)
go sub()
}
// 等待子协程执行完再执行主协程
wp.Wait()
fmt.Printf("count: %v \n", count)
fmt.Println("end...")
}
进程、线程、协程
- 进程(Process):进程是操作系统中的一个执行实体,代表一个程序的运行实例。每个进程都有自己的独立内存空间和系统资源,如文件、网络连接等。进程间是相互独立的,通过操作系统进行资源分配和调度。进程之间的通信需要使用特定的通信机制,如管道、信号量等
- 线程(Thread):线程是进程中的一个执行流,也被称为轻量级进程。一个进程可以创建多个线程,它们共享进程的内存空间和系统资源。线程之间切换的开销相对较小,因为它们共享了大部分上下文和资源。多线程可以实现并发执行,提高程序的效率和响应性。但线程之间的共享资源需要注意同步和互斥的问题,以避免竞态条件和死锁等并发问题
- 协程(Coroutine):协程是一种用户级的轻量级线程,也被称为协作式多任务。与线程不同,协程的调度是由用户代码来控制的,而不是由操作系统进行调度。在协程中,任务的切换是协作式的,即一个任务让出 CPU 给其他任务执行。协程通常具有低开销和高效率的特点,适合于处理大量的并发任务和高度并发的网络编程
总结起来,进程是系统资源分配和调度的独立单位,线程是 CPU 资源分配和调度的基本单位,协程是一种用户级的轻量级线程,通过用户代码进行调度。它们在实现并发和多任务处理方面具有不同的特点和应用场景。
进程调度算法
进程调度是操作系统或运行时系统决定将 CPU 时间片分配给哪个进程以执行的过程。进程调度的目标是提高系统的吞吐量、响应性和公平性。
进程调度算法通常基于优先级、时间片轮转、抢占式和非抢占式等原则。以下是一些常见的进程调度算法。
- 先来先服务(FCFS)
顾名思义,先来后到,每次从就绪队列选择最先进入队列的进程,然后一直运行,直到进程退出或被阻塞,才会继续从队列中选择一个进程接着运行。
这似乎很公平,但是当一个长作业先运行了,那么后面的短作业等待的时间就会很长,不利于短作业。
FCFS 对长作业有利,适用于 CPU 繁忙型作业的系统,而不适用于 I/O 繁忙型作业的系统。
- 最短作业优先
顾名思义,它会优先选择运行时间最短的进程来运行,这有助于提高系统的吞吐量。
这显然对长作业不利,很容易造成一种极端现象。
比如,一个长作业在就绪队列等待运行,而这个就绪队列有非常多的短作业,那么就会使得长作业不断地往后推,周转时间变长,致使长作业长期不会被运行。
- 高响应比优先
主要是权衡了短作业和长作业,每次进行进程调度时,先计算「响应比优先级」,然后把「响应比优先级」最高的进程投入运行。
如果两个进程的「等待时间」相同时,「要求服务时间」越短,「响应比」就越高,这样短作业的进程容易被选中运行。
如果两个进程「要求服务时间」相同时,「等待时间」越长,「响应比」就越高,这就兼顾到了长作业进程,因为进程的响应比可以随时间等待的增加而提高,当其等待时间足够长时,其响应比便可以升到很高,从而获得运行的机会。
- 时间片轮转
将 CPU 时间划分为固定长度的时间片,每个进程按照时间片轮流执行。
如果时间片用完,进程还在运行,那么将会把此进程从 CPU 释放出来,并把 CPU 分配给另外一个进程。
如果该进程在时间片结束前阻塞或结束,则 CPU 立即进行切换。
如果时间片设得太短会导致过多的进程上下文切换,降低 CPU 效率。
如果设得太长又可能引起对短作业进程的响应时间变长。
一般来说,时间片设为 20ms ~ 50ms 通常是一个比较合理的折中值。
- 最高优先级
「时间片轮转」让所有的进程同等重要,大家的运行时间都一样。
但是,对于多用户计算机系统而言,它们希望调度是有优先级的,即希望调度程序能从就绪队列中选择最高优先级的进程进行运行。
进程的优先级可以分为静态优先级和动态优先级。
静态优先级:创建进程时候,就已经确定了优先级了,然后在整个运行时间,优先级都不会变化。
动态优先级:根据进程的动态变化调整优先级,比如进程运行时间增加,则降低其优先级;进程等待时间(就绪队列的等待时间)增加,则升高其优先级,即随着时间的推移增加等待进程的优先级。
该算法也有两种处理优先级高的方法,分别为非抢占式和抢占式。
非抢占式:当就绪队列中出现优先级高的进程,运行完当前进程,再选择优先级高的进程。
抢占式:当就绪队列中出现优先级高的进程,当前进程挂起,调度优先级高的进程运行。
但是这种算法依然有缺点,可能会导致低优先级的进程永远不会运行。
- 多级反馈队列
是「时间片轮转算法」和「最高优先级算法」的综合和发展。
顾名思义,「多级」表示有多个队列,每个队列优先级从高到低,同时优先级越高时间片越短;「反馈」表示如果有新的进程加入优先级高的队列时,立刻停止当前正在运行的进程,转而去运行优先级高的队列。
设置了多个队列,赋予每个队列不同的优先级,每个队列优先级从高到低,同时优先级越高时间片越短。
新的进程会被放入到第一级队列的末尾,按先来先服务的原则排队等待被调度,如果在第一级队列规定的时间片内没运行完成,则将其转入到第二级队列的末尾,以此类推,直至完成。
当较高优先级的队列为空时,才调度较低优先级的队列中的进程运行。如果进程运行时,有新进程进入较高优先级的队列,则停止当前运行的进程并将其移入到原队列末尾,接着让较高优先级的进程运行。
可以发现,对于短作业,可能在第一级队列就很快被处理完。对于长作业,如果在第一级队列处理不完,可以移入下一队列等待被执行,虽然等待的时间变长了,但是运行时间也变长了,所以该算法很好地兼顾了长短作业,同时又有较好的响应时间。