Java线程和Go协程

Java线程和Go协程

Java线程和Go协程都是用于并发编程的工具，但在实现和使用上有一些不同。

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同步机制

1. synchronized关键字： Java提供了synchronized关键字来控制对共享资源的并发访问，确保线程安全。

2. ReentrantLock： ReentrantLock是一种基于AQS框架的可重入互斥锁，提供了比synchronized更多的功能。

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

---

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

这种方式有两大不足：

1. 复杂性：

   • 创建容易、退出难。

   • 需要父线程去通知并等待子线程退出（join）。

   • 并发单元间通信困难：涉及到共享内存，就会用到锁，容易出现死锁。

   • 线程栈大小的设置。

2. 扩展性：

   • 不能创建大量线程，因为每个线程占用的资源不小，操作系统调度切换线程的代价也不小。

   • 对于很多网络服务程序，由于不能大量创建线程，就要在少量线程里做网络的多路复用，即使用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 = 0
 mutex   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.WaitGroup

 for 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.WaitGroup
 ch := 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 分配到工作线程上。

主要流程：

1. go func来创建一个goroutine。

2. 有两个存储G的队列，一个是局部调度器P的本地队列，一个是全局队列。先创建的G会先保存在P的本地队列，本地满了后会保存在全局队列中。

3. G只能运行在M中，一个M必须持有一个P，M和P是1:1的关系。M会从P的本地队列弹出一个可执行状态的G来执行，如果P的本地队列为空，就会从其它线程的P队列中偷取G执行。

4. 当M执行某一个G时发生了syscall或者阻塞操作，M会阻塞，如果当前有一些G在执行，runtime会把这个线程M从P中摘除，然后再创建一个新的操作系统的线程（如果有空闲的线程可用就复用空闲线程）来服务于这个P。

5. 当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. 1/61的概率从全局队列取协程；

2. 从本地队列获取协程；

3. 从全局队列获取协程；

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

5. 从其它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放入全局队列等待调度。

---

窃取：

从其它P中窃取一半的任务，窃取个数n = x - x / 2。假如x有3个元素，则窃取2个。

Go 中协程窃取机制和 Java 并行流中窃取任务机制思想一致，都是从其它队列偷取任务，放到自个队列中执行。

Java并行流任务窃取可见《ForkJoinPool源码解析》。

总结

Java中需要手动管理线程的生命周期和同步机制。为了复用线程，还需要创建线程池来达到线程的复用，此时线程池的参数也需要用户自己调试。

而在Go中是由Go 语言自动管理协程的生命周期和调度。此外，Go协程的通信机制更加灵活，可以通过通道实现协程之间的数据传递和同步。

参考资料

1. 《Go语言精进之路》。