从Java线程到Go协程：一个Java程序员的“轻功“修炼之路

引言：当Java程序员遇上Go协程

作为一个写了多年Java的老程序员，我曾经对Thread类和ExecutorService了如指掌，自以为对多线程已经驾轻就熟。直到有一天，我决定学习Go，然后……我被Go的协程（Goroutine）狠狠地刷新了三观。

在Java里，线程是"重装战士"，启动一个线程就像召集一个特种兵，成本高、数量有限，还得小心翼翼地管理。而在Go里，协程是"轻功高手"，轻轻一跃就能创建成千上万个，跑得飞快，还不怎么占资源。今天，我就来聊聊Java线程和Go协程的区别，用最接地气的方式，帮你理解这个转变。

1. 线程 vs 协程：重量级 vs 轻量级

Java线程：“重装战士”

在Java里，线程是操作系统级别的概念。当你调用new Thread(() -> { ... }).start()时，JVM会向操作系统申请一个真正的线程，这个线程有自己的栈内存（默认1MB左右），由操作系统调度。

问题来了：

线程创建成本高：每次创建线程，操作系统都要分配资源，初始化栈、上下文等。
线程数量有限：一个Java程序通常只能开几百个线程，再多的话，内存和CPU调度就会扛不住。
线程切换开销大：线程多了，操作系统在它们之间切换（上下文切换）会很耗CPU。

举个例子：

for (int i = 0; i < 10000; i++) {
    new Thread(() -> {
        System.out.println("Hello from thread!");
    }).start();
}

这段代码理论上能创建1万个线程，但实际上，你的电脑可能会直接卡死，或者抛出OutOfMemoryError，因为每个线程都要占用1MB左右的栈内存，1万个线程就是10GB内存！（当然，JVM可能会限制最大线程数，但无论如何，这都不是一个好主意。）

Go协程：“轻功高手”

Go的协程（Goroutine）是Go运行时（Runtime）管理的，不是操作系统线程。一个Goroutine的栈初始只有几KB（2KB左右），并且可以动态增长/收缩。Go的调度器（Scheduler）会在少量操作系统线程上运行成千上万个Goroutine。

优势：

协程创建成本极低：启动一个Goroutine几乎不花什么资源。
可以轻松创建成千上万个：Go程序可以轻松跑几十万甚至上百万个Goroutine。
调度高效：Go的调度器（GMP模型）在用户态管理协程，减少了操作系统线程切换的开销。

举个例子：

for i := 0; i < 10000; i++ {
    go func() {
        fmt.Println("Hello from goroutine!")
    }()
}

这段代码在Go里运行毫无压力，1万个Goroutine可能只占用几十MB内存，而且Go的调度器会高效地管理它们。

幽默对比：

Java线程：像招特种兵，一个特种兵（线程）要配一辆装甲车（内存）、一个指挥官（调度），成本高，数量有限。
Go协程：像招轻功高手，一个高手（Goroutine）轻功了得，跑得快，还不占地方，随便招几千个都没问题。

2. 线程调度 vs 协程调度：操作系统 vs Go运行时

Java线程：操作系统调度

Java的线程是由操作系统内核调度的，这意味着：

线程切换要进内核态：每次线程切换，CPU要从用户态切换到内核态，开销较大。
调度策略由操作系统决定：你无法控制线程的执行顺序，只能靠Thread.sleep()、wait()等手动控制。

问题：

如果你有大量线程，操作系统会频繁切换，CPU时间都浪费在调度上了。
线程阻塞（比如I/O操作）会导致线程挂起，浪费资源。

Go协程：Go运行时调度（GMP模型）

Go的协程是由Go运行时（Runtime）调度的，它的调度器叫GMP模型：

G（Goroutine）：就是协程本身。
M（Machine）：代表操作系统线程（真正执行代码的线程）。
P（Processor）：代表逻辑处理器，管理本地Goroutine队列（每个P有一个本地队列，还有一个全局队列）。

调度过程：

Goroutine 由 P 管理，P 绑定一个 M（线程） 来执行。
如果 Goroutine 阻塞（比如I/O），P 会把这个 Goroutine 挂起，并从队列里拿一个新的 Goroutine 给 M 执行，避免线程空转。
Go运行时 会动态调整 P 的数量（默认是CPU核心数），最大化利用CPU。

优势：

用户态调度：Go的调度器在用户态工作，不需要频繁进入内核态，减少开销。
更少的线程，更多的协程：Go可能只用几个操作系统线程（M），但能跑成千上万个Goroutine。
阻塞不会浪费线程：如果一个Goroutine阻塞（比如网络请求），Go会自动把其他Goroutine调度到同一个线程上执行。

幽默对比：

Java线程调度：像公司老板（操作系统）亲自安排每个员工（线程）的工作，员工多了，老板累得要死，还容易安排错。
Go协程调度：像公司有一个超级HR（Go运行时），它自动安排员工（Goroutine）干活，员工多了也不怕，HR会智能调配，让少数几个办公桌（线程）高效运转。

3. 阻塞与并发：Java的"堵车" vs Go的"畅通"

Java：线程阻塞 = 资源浪费

在Java里，如果一个线程执行了阻塞操作（比如Socket.read()、synchronized、wait()），这个线程就会被挂起，直到阻塞结束。这意味着：

线程被占用，不能干别的活。
如果很多线程阻塞，系统很快就会耗尽线程资源。

例子：

// 假设这是一个网络请求
new Thread(() -> {
    try {
        Socket socket = new Socket("example.com", 80);
        InputStream in = socket.getInputStream(); // 阻塞！
        // ... 读取数据
    } catch (IOException e) {
        e.printStackTrace();
    }
}).start();

如果同时开1000个这样的线程，大部分线程可能都在等待网络响应，CPU却没事干，内存却被占满了。

Go：协程阻塞 = 自动调度

在Go里，如果一个Goroutine阻塞（比如网络I/O、channel操作、time.Sleep），Go的调度器会自动把这个Goroutine挂起，并让其他Goroutine在同一个线程上运行。这意味着：

线程不会被浪费，即使Goroutine阻塞，线程还能继续执行其他任务。
Go的I/O操作通常是异步的（底层用epoll/kqueue等机制），不会真的阻塞线程。

例子：

go func() {
    resp, err := http.Get("http://example.com") // 阻塞？不，Go会智能调度！
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()
    // ... 处理响应
}()

即使有1万个Goroutine在等HTTP响应，Go的调度器也能高效管理，不会让线程傻等。

幽默对比：

Java线程阻塞：像高速公路上堵车，一辆车堵住了，后面的车都得停下来，交警（操作系统）也没办法，只能干等着。
Go协程阻塞：像高速公路上有智能调度系统，一辆车堵住了，调度系统马上让其他车换车道（线程）继续跑，一点不浪费资源。

4. 如何优雅地从Java线程过渡到Go协程？

Java习惯：`Thread` + `ExecutorService`

Java程序员通常这样管理线程：

ExecutorService executor = Executors.newFixedThreadPool(10); // 限制10个线程
for (int i = 0; i < 100; i++) {
    executor.submit(() -> {
        System.out.println("Running in thread pool");
    });
}
executor.shutdown();

优点：控制线程数量，避免资源耗尽。
缺点：线程池大小固定，仍然依赖操作系统线程。

Go习惯：直接`go`关键字

Go程序员直接go关键字启动协程，不需要手动管理线程池：

for i := 0; i < 100; i++ {
    go func() {
        fmt.Println("Running in goroutine")
    }()
}
// Go会自动调度，你只需要确保主协程不退出（比如用sync.WaitGroup）

优点：简单、高效，协程数量可以轻松扩展。
缺点：需要理解channel和sync包来管理并发安全。

如何适应？

别手动管理"线程池"：Go的调度器比你更懂怎么管理协程。
用channel代替共享内存：Go鼓励用channel通信，而不是像Java那样用synchronized锁。
理解sync.WaitGroup：用来等待一组Goroutine完成（类似Java的CountDownLatch）。

5. 总结：Java线程 vs Go协程

特性	Java线程	Go协程
底层实现	操作系统线程	Go运行时管理
栈大小	默认1MB	初始2KB，动态调整
创建成本	高（内存+调度）	极低（几KB）
最大数量	几百个（受内存限制）	几十万个（轻松）
调度方式	操作系统调度（内核态）	Go运行时调度（用户态）
阻塞影响	线程挂起，资源浪费	自动调度，不浪费线程
并发模型	`Thread` + `synchronized`	`goroutine` + `channel`