Java在Ubuntu上的多线程编程教程

时间：2026-07-18

在 Ubuntu 上进行 Ja va 多线程编程的入门与实战教程

Ja va在Ubuntu上的多线程编程教程

先说一个很实在的判断：如果你在 Ubuntu 上写 Ja va 多线程程序，环境准备其实比想象中简单得多，真正需要花心思的，是理解线程的创建方式、生命周期管理，以及如何安全地共享数据。下面咱们就从最基础的环境搭建开始，一步步深入到实战代码，最后再聊聊调试和排错那些事儿。

一、环境准备

在 Ubuntu 上开发 Ja va 多线程，核心就是装好 JDK，然后会用 ja vac/ja va 命令。推荐使用 OpenJDK 17 或 21 LTS，稳定性有保障。

安装 OpenJDK：先更新索引再安装，一句命令搞定：sudo apt update && sudo apt install openjdk-17-jdk
验证安装：ja va -version 和 ja vac -version 两个命令都能正常输出版本信息就算成功。
可选配置 JA VA_HOME：有些工具（比如 Ma ven、Gradle）需要这个环境变量。查找路径：update-alternatives --config ja va，然后写进 ~/.bashrc，记得 source ~/.bashrc 使其生效。

一句话总结：装上 JDK，配好路径，其他 Linux 发行版上的经验完全通用。

二、三种创建线程的方式

创建线程的方式很多，但主流就三种，各有各的适用场景。

方式一：继承 Thread
重写 run() 方法，然后调用 start() 启动新线程。简单粗暴，适合快速验证思路，但生产代码里不推荐，因为继承破坏了灵活性。
方式二：实现 Runnable
任务和线程对象解耦，同一个 Runnable 实例可以丢给多个线程执行，复用性更好。实际项目中更推荐这种方式。
方式三：使用 Executor 框架（强烈推荐）
通过 ExecutorService 管理线程生命周期，支持 Runnable、Callable、Future，还能方便地获取返回值和处理异常。这是现代 Ja va 并发编程的标配。

另外，线程的生命周期可以速记为：新建（New）→ 就绪（Runnable）→ 运行（Running）→ 阻塞（Blocked）→ 终止（Terminated）。记住这个流转图，调试时能帮你快速定位问题。

三、完整示例：线程池 + Callable + Future + 同步

光说不练假把式，来看一个真实可跑的代码。这个例子用固定线程池并行计算 1 到 N 的累加和，演示了 Callable、Future、线程安全计数以及优雅关闭。

import ja va.util.concurrent.*;

public class ThreadPoolSum {
    // 线程安全计数器
    static class Counter {
        private final Object lock = new Object();
        private int n = 0;
        void add(int delta) { synchronized (lock) { n += delta; } }
        int get() { synchronized (lock) { return n; } }
    }

    static class SumTask implements Callable {
        private final long from, to;
        SumTask(long from, long to) { this.from = from; this.to = to; }
        @Override public Long call() {
            long sum = 0;
            for (long i = from; i <= to; i++) sum += i;
            // 模拟少量 I/O 或计算抖动
            try { Thread.sleep(1); } catch (InterruptedException ignored) {}
            return sum;
        }
    }

    public static void main(String[] args) throws Exception {
        int n = 1_000_000;
        int threads = Runtime.getRuntime().a vailableProcessors(); // 贴近 CPU 核心数
        ExecutorService exec = Executors.newFixedThreadPool(threads);
        long t0 = System.nanoTime();

        Future[] futures = new Future[threads];
        long chunk = n / threads;
        for (int i = 0; i < threads; i++) {
            long from = i * chunk + 1;
            long to = (i == threads - 1) ? n : (i + 1) * chunk;
            futures[i] = exec.submit(new SumTask(from, to));
        }

        long total = 0;
        for (Future f : futures) total += f.get(); // 阻塞等待结果
        long t1 = System.nanoTime();

        exec.shutdown();
        exec.awaitTermination(10, TimeUnit.SECONDS);
        System.out.printf("Sum[1..%d] = %d, 耗时 %.3f ms%n", n, total, (t1 - t0) / 1_000_000.0);
    }
}

编译运行：ja vac ThreadPoolSum.ja va 然后 ja va ThreadPoolSum。输出结果应该是一个正确的累加和，以及一个几毫秒到几十毫秒的耗时。

几个关键点：

用 ExecutorService 管理线程，避免频繁创建/销毁线程的开销。
Callable/Future 可以获取任务返回值，同时 Future.get() 会抛出异常，方便处理任务中的错误。
共享数据（比如这里的 Counter）使用 synchronized 保证线程安全，或者直接用 ja va.util.concurrent 包里的原子类。

四、线程安全与常见并发工具

多线程编程的核心难点从来不是“怎么启动线程”，而是“怎么让多个线程安全地协作”。下面这些工具你得熟悉。

同步机制
- synchronized 方法/代码块：最基础的互斥锁，保证同一时刻只有一个线程进入临界区。
- ReentrantLock：显式锁，支持尝试锁、超时、公平锁等更灵活的语义，适合复杂场景。
并发容器
- ConcurrentHashMap、CopyOnWriteArrayList 等，在高并发读写场景下比传统容器更安全、更高效。
同步辅助类
- CountDownLatch 用于等待一组线程完成，CyclicBarrier 用于多线程互相等待，Semaphore 用于限流。