目录
一、这篇文章怎么用
二、先给你一个总览
三、最基础：开一个线程
四、实现 Runnable 的对照写法
五、等待线程结束
六、线程池（最常用）
七、拿到线程返回值
八、共享数据与锁
九、线程安全集合的替代
十、任务很多时怎么批量提交
十一、Java 的 CompletableFuture 对照 Python asyncio
十二、什么时候用线程，什么时候用异步
十三、最容易踩的坑
结语
一、这篇文章怎么用
你会 Java 多线程，那么看 Python 并发其实很简单。本文完全按照“Java 写法 → Python 写法 → 一句话理解”来写，不讲术语，不绕概念，直接告诉你怎么写。
目标：看完你能把 Java 的多线程思路直接套到 Python，并且知道什么时候用线程、什么时候用异步。
二、先给你一个总览
- Java 多线程：Thread / Runnable / Executor
- Python 多线程：threading.Thread
- Java 线程池：Executors.newFixedThreadPool
- Python 线程池：concurrent.futures.ThreadPoolExecutor
- Java 异步：CompletableFuture
- Python 异步：asyncio + async/await
三、最基础：开一个线程
Java 写法：
// Java class MyTask extends Thread { public void run() { System.out.println("hello"); } } new MyTask().start();
Python 写法：
# Python import threading def task(): print("hello") t = threading.Thread(target=task) t.start()
一句话理解：Java 用 Thread 子类，Python 用函数 + Thread。
四、实现 Runnable 的对照写法
// Java Runnable r = () -> System.out.println("run"); new Thread(r).start();
# Python def r(): print("run") threading.Thread(target=r).start()
一句话理解：Java 的 Runnable 就是 Python 里的函数。
五、等待线程结束
// Java Thread t = new Thread(() -> {}); t.start(); t.join();
# Python t = threading.Thread(target=lambda: None) t.start() t.join()
一句话理解：join 在两边都是“等线程结束”。
六、线程池（最常用）
Java 线程池：
// Java ExecutorService pool = Executors.newFixedThreadPool(4); pool.submit(() -> System.out.println("task")); pool.shutdown();
Python 线程池：
# Python from concurrent.futures import ThreadPoolExecutor with ThreadPoolExecutor(max_workers=4) as pool: pool.submit(lambda: print("task"))
一句话理解：Java pool.submit 对应 Python pool.submit。
七、拿到线程返回值
// Java Future<Integer> f = pool.submit(() -> 1 + 2); int v = f.get();
# Python f = pool.submit(lambda: 1 + 2) v = f.result()
一句话理解：Java Future.get 对应 Python Future.result。
八、共享数据与锁
// Java synchronized(this) { count++; }
# Python lock = threading.Lock() with lock: count += 1
一句话理解：Java synchronized 对应 Python Lock。
九、线程安全集合的替代
Java 用 ConcurrentHashMap；Python 没有内置线程安全 dict，但可以用锁保护。
# Python lock = threading.Lock() data = {} with lock: data[key] = value
一句话理解：Python 靠锁保证安全。
十、任务很多时怎么批量提交
# Python with ThreadPoolExecutor(max_workers=4) as pool: futures = [pool.submit(work, x) for x in items] for f in futures: print(f.result())
一句话理解：submit + result 就能做批量并发。
十一、Java 的 CompletableFuture 对照 Python asyncio
Java 异步：
// Java CompletableFuture.supplyAsync(() -> 1) .thenApply(x -> x + 1) .thenAccept(System.out::println);
Python 异步：
# Python import asyncio async def work(): return 1 async def main(): x = await work() print(x + 1) asyncio.run(main())
一句话理解：Java 链式回调，Python 用 await。
十二、什么时候用线程，什么时候用异步
- IO 多（网络/文件）：Python 线程或 asyncio 都可以
- CPU 多（计算）：Python 多进程更合适，线程提升不明显
- 简单项目：直接线程池最省事
十三、最容易踩的坑
- 线程开太多，机器反而更慢
- 忘记 join 导致主线程提前结束
- 多个线程改同一个变量却没加锁
- 把 CPU 密集任务放线程里，以为会更快
结语
如果你会 Java 多线程，Python 并发其实就是“同一套思路，换一套写法”。这篇文章给的是最直白的对照写法，你可以直接照抄。后面如果你想看“线程池实战场景”，我可以继续补。
