进程（Process）、线程（Thread） 和 协程（Coroutine） 是并发和并行编程的核心概念。那么Java 和 Python 在这些方面的实现是怎么样的呢，下面我们来详细对比一下。

1. 进程（Process）

概念：

• 进程是程序运行时的实例，拥有独立的内存空间和资源。
• 进程间的通信（IPC, Inter-Process Communication）通常比较复杂，因为它们不共享内存。

Java 进程

Java 主要使用 ProcessBuilder 和 Runtime.exec() 来创建进程。

示例：创建子进程执行 shell 命令

import java.io.*;

public class ProcessExample {
    public static void main(String[] args) throws IOException {
        ProcessBuilder processBuilder = new ProcessBuilder("echo", "Hello from Java");
        Process process = processBuilder.start();

        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    }
}

Python 进程

Python 使用 multiprocessing 模块处理进程，提供更高层次的封装。

示例：创建子进程

import multiprocessing

def worker():
    print("Hello from Python process")

if __name__ == "__main__":
    p = multiprocessing.Process(target=worker)
    p.start()
    p.join()

特点：

• 避免 GIL（全局解释器锁），适用于 CPU 密集型任务，如数据处理。
• 进程池（Pool） 支持并行计算。

2. 线程（Thread）

概念：

• 线程是操作系统调度的基本单位，属于进程的一部分，共享内存，创建比进程更轻量。
• 适用于 I/O 密集型任务，如文件操作、网络请求、数据库查询。

Java 线程

Java 使用 Thread 类或 ExecutorService 管理线程。

示例：创建线程

class MyThread extends Thread {
    public void run() {
        System.out.println("Hello from Java thread");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

使用线程池（ExecutorService）

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Runnable task = () -> System.out.println("Hello from thread pool");
        executor.submit(task);
        executor.shutdown();
    }
}

你还知道怎么创建线程不？

Python 线程

Python 通过 threading 模块创建线程，但受 GIL（全局解释器锁） 影响，多个线程不能真正并行执行 Python 代码。

示例：创建线程

import threading

def worker():
    print("Hello from Python thread")

t = threading.Thread(target=worker)
t.start()
t.join()

线程池（ThreadPoolExecutor）

from concurrent.futures import ThreadPoolExecutor

def worker():
    print("Hello from thread pool")

with ThreadPoolExecutor(max_workers=2) as executor:
    executor.submit(worker)

受 GIL 限制，Python 线程不能真正并行执行 CPU 密集型任务。

1. 那什么事GIL：
2. GIL（全局解释器锁） 是 Python 解释器 级别的锁，它 限制了同一时刻只有一个线程执行 Python 代码，即使在多核 CPU 上也是如此。
3. GIL 的存在导致 Python 无法真正实现多线程并行计算，这在 CPU 密集型任务（如数学计算、数据处理）中是一个显著的性能瓶颈。
4. 怎么解决：

方法 1：使用 multiprocessing 代替 threading -- 用进程代替线程，。。

方法 2：使用 C/C++ 扩展（NumPy, TensorFlow 等）

方法 3：使用 JIT 编译器（如 PyPy）

3. 协程（Coroutine）

概念：

• 协程是比线程更轻量的并发单位，不依赖操作系统线程，由 语言自身调度。
• 适用于 高并发 I/O 任务，如 异步 HTTP 请求、数据库查询。
• 区别： 线程由 操作系统调度，协程由 应用程序调度。

Java 协程

Java 17+ 通过 Virtual Threads（虚拟线程）提供类似协程的功能（Project Loom）。

示例：虚拟线程

public class VirtualThreadExample {
    public static void main(String[] args) {
        Thread.startVirtualThread(() -> {
            System.out.println("Hello from virtual thread");
        });
    }
}

Python 协程

Python 使用 asyncio 实现协程，比线程更轻量。有点像js中的异步任务。

示例：协程

import asyncio

async def worker():
    print("Hello from coroutine")

asyncio.run(worker())

多个协程并发

import asyncio

async def worker(n):
    print(f"Task {n} started")
    await asyncio.sleep(2)
    print(f"Task {n} done")

async def main():
    await asyncio.gather(worker(1), worker(2), worker(3))

asyncio.run(main())

优点：

• 比线程更轻量，适用于 高并发 I/O 任务（如 Web 服务器）。
• 非阻塞，比线程更高效。

缺点：

• 代码风格不同，需要 async / await 语法。
• 仅适用于 I/O 密集型任务，不适用于 CPU 密集型任务。

4. Java vs Python：进程、线程、协程对比

搞定进程线程和协程后呢，就到面向对象了。 加油~