Java线程模型

Java线程是Java语言提供的一种并发编程的机制，它允许程序在同一时间执行多个任务。Java线程是基于操作系统的线程实现的，每个线程都有自己的堆栈和程序计数器，并且可以通过调度器进行调度。Java线程可以通过继承Thread类或实现Runnable接口来创建和启动。

两种方式启动线程：

继承Thread。
实现Runnable接口。

class MyThread extends Thread {public void run() {// 线程的主要逻辑// ...}
}public class Main {public static void main(String[] args) {MyThread thread = new MyThread();thread.start(); // 启动线程}
}

class MyRunnable implements Runnable {public void run() {// 线程的主要逻辑// ...}
}public class Main {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread thread = new Thread(myRunnable);thread.start(); // 启动线程}
}

Java同步机制

synchronized关键字： Java提供了synchronized关键字来控制对共享资源的并发访问，确保线程安全。
ReentrantLock： ReentrantLock是一种基于AQS框架的可重入互斥锁，提供了比synchronized更多的功能。

AQS原理参考之前文章：《Java AQS实现》。

Java并发实现是基于操作系统调度的，即程序负责创建线程，操作系统负责调度。

这种方式有两大不足：

复杂性：
- 创建容易、退出难。
- 需要父线程去通知并等待子线程退出（join）。
- 并发单元间通信困难：涉及到共享内存，就会用到锁，容易出现死锁。
- 线程栈大小的设置。
扩展性：
- 不能创建大量线程，因为每个线程占用的资源不小，操作系统调度切换线程的代价也不小。
- 对于很多网络服务程序，由于不能大量创建线程，就要在少量线程里做网络的多路复用，即使用epoll/kqueue。

Go协程模型

Go协程是Go语言提供的一种轻量级的并发编程机制。

Go协程是由Go语言运行时环境管理的，它可以在同一个线程上运行多个协程。Go协程使用关键字"go"来创建，可以通过go关键字将一个函数调用转换为一个协程。Go协程之间通过通道（channel）进行通信，以实现数据的传递和同步。

Go中启动协程：

func main() {// 启动一个协程go sayHello("Hello from Goroutine 1")
}

Go同步机制：

Channel： Channel是Go中用于协程间通信和同步的主要机制。
Mutex： Mutex用于控制共享资源的访问，保证数据的完整性和一致性。

Go始终推荐以CSP（通信进程顺序）模型风格构建并发程序，也就是使用channel。channel实现了CSP模型中的输入/输出原语。

Mutex示例：

var (counter = 0mutex   sync.Mutex
)func incrementCounter(wg *sync.WaitGroup) {defer wg.Done()// 加锁mutex.Lock()defer mutex.Unlock()// 访问共享变量counter++fmt.Printf("Counter: %d\n", counter)
}func main() {var wg sync.WaitGroupfor i := 0; i < 5; i++ {wg.Add(1)go incrementCounter(&wg)}// 等待所有 Goroutines 完成wg.Wait()
}

Channel示例：

var (counter = 0
)func incrementCounter(wg *sync.WaitGroup, ch chan bool) {defer wg.Done()// 发送消息通知其他 Goroutine 进行更新ch <- true// 访问共享变量counter++fmt.Printf("Counter: %d\n", counter)// 发送消息通知完成<-ch
}func main() {var wg sync.WaitGroupch := make(chan bool, 1)for i := 0; i < 5; i++ {wg.Add(1)go incrementCounter(&wg, ch)}// 等待所有 Goroutines 完成wg.Wait()// 关闭通道close(ch)
}

Goroutine调度器 GPM 模型：

G（Goroutine）：协程（轻量级线程）。存储了 goroutine 的执行栈信息、goroutine状态及goroutine的任务函数等。
P（Processor）：包含了运行 goroutine 的资源，如果线程想运行 goroutine，必须先获取P，P中还包含了可运行的G队列。
M（Thread）：代表真正的执行计算资源。从P的本地队列中获取G，切换到G的执行栈上并执行G的函数。

在go中，线程 M 是运行 goroutine 的实体，调度器 P 的功能是把可运行的 goroutine 分配到工作线程上。

主要流程：

go func来创建一个goroutine。
有两个存储G的队列，一个是局部调度器P的本地队列，一个是全局队列。先创建的G会先保存在P的本地队列，本地满了后会保存在全局队列中。
G只能运行在M中，一个M必须持有一个P，M和P是1:1的关系。M会从P的本地队列弹出一个可执行状态的G来执行，如果P的本地队列为空，就会从其它线程的P队列中偷取G执行。
当M执行某一个G时发生了syscall或者阻塞操作，M会阻塞，如果当前有一些G在执行，runtime会把这个线程M从P中摘除，然后再创建一个新的操作系统的线程（如果有空闲的线程可用就复用空闲线程）来服务于这个P。
当M系统调用结束时候，这个G会尝试获取一个空闲的P执行，并放入到这个P的本地队列。如果获取不到P，那么这个线程M变成休眠状态，加入到空闲线程中，然后这个G会被放入全局队列中。

Go协程调度策略

源码：go1.20/src/runtime/proc.go

//找到一个可运行的协程以执行
func findRunnable() (gp *g, inheritTime, tryWakeP bool) {// 偶尔从全局队列拿取协程保证公平性if pp.schedtick%61 == 0 && sched.runqsize > 0 {...}// 本地队列获取协程if gp, inheritTime := runqget(pp); gp != nil {return gp, inheritTime, false}// 全局队列获取协程if sched.runqsize != 0 {...}// 从网络轮询队列中获取事件//当一个goroutine（G、协程）在等待网络响应或某种I/O操作时，它会被阻塞，此时不会影响P队列中的其它G执行。//阻塞的goroutine等待网络响应数据到达后，G1会被从新放入P的本地队列，本地队列满了会被放入全局队列等待调度。//如果G被阻塞在某个channel操作或者网络I/O操作上，那么G会被放置到某个等待队列中，而M会尝试运行P的下一个可运行的G、if netpollinited() && netpollWaiters.Load() > 0 && sched.lastpoll.Load() != 0 {...}// 从其它P中窃取一半的任务，窃取个数n = x - x / 2。假如x有3个元素，则窃取2个if mp.spinning || 2*sched.nmspinning.Load() < gomaxprocs-sched.npidle.Load() {...}}

按如下顺序调度获取协程执行：

1/61的概率从全局队列取协程；

从本地队列获取协程；

从全局队列获取协程；

从网络轮询队列中获取协程事件；

从其它P队列中窃取协程。

阻塞调度：

网络I/O阻塞：
当一个 goroutine 在等待网络响应或某种I/O操作时，它会被阻塞，此时G会被放置到某个等待队列中，而M会尝试运行P的下一个可运行G。也就是说P中其它的G仍然可以并发执行。

待阻塞的goroutine等待网络响应数据到达后，G会被重新放入P的本地队列，本地队列满了会被放入全局队列等待调度。
系统调用阻塞：
当一个G被阻塞在系统调用上，那么G会阻塞，执行该G的M也会解绑P，与G一起进行入阻塞状态。此时有空闲的M，则与P绑定并执行P中其它的G，没有空闲的M则创建新的M绑定P并执行。

当系统调用返回后，阻塞的G会尝试获取一个可用的P，有可用的P则将之前运行G的M与P绑定继续运行G。没有可用的P则G与M的关联解除，并将G放入全局队列等待调度。