很多刚接触Ja va多线程的朋友，在Ubuntu上搭建环境时，常会遇到一些不适应的问题。其实，只要把几个关键点理清楚，整个过程就会顺畅很多。

下面这份指南，从环境准备到实战技巧，系统梳理Ja va多线程开发的要点。

1. 环境准备

在Ubuntu上搞Ja va多线程，第一步是确保已经安装合适的JDK。

推荐使用OpenJDK 17以上的版本，稳定性和性能都足够日常开发。

sudo apt update
sudo apt install openjdk-17-jdk

安装完成后，可以顺手验证一下版本信息：

ja va -version
# 查看JDK版本
ja vac -version 
# 查看编译器版本

如果版本号能够正常输出，说明环境已经配置完成。

2. 线程创建：两种基础方式

Ja va里创建线程，主要有两种方式：

• 继承Thread类
• 实现Runnable接口

实际开发中，更推荐使用Runnable接口。这样可以避开Ja va单继承带来的限制，代码也更灵活。

继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程（自动调用run()）
    }
}

实现Runnable接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

注意：直接调用run()只是普通方法调用，不会启动新线程。

只有调用start()，JVM才会创建新线程来执行任务。

3. 线程同步：解决数据竞争

多线程一旦开始共享资源，就容易出现数据竞争问题。

多个线程同时修改同一份数据，结果往往会变得不可控。这时就需要同步机制。

synchronized关键字

synchronized是最基础的同步方式。

• 修饰实例方法时，锁的是当前对象
• 修饰静态方法时，锁的是Class对象
• 修饰代码块时，锁的是指定对象

class Counter {
    private int count = 0;
    
    // 同步实例方法（锁当前对象）
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块（锁this对象）
    public void safeIncrement() {
        synchronized (this) {
            count++;
        }
    }
}

ReentrantLock显式锁

如果需要更灵活的锁控制，比如尝试获取锁、超时设置、公平锁，那么ReentrantLock会更合适。

import ja va.util.concurrent.locks.Lock;
import ja va.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++; // 临界区代码
        } finally {
            lock.unlock(); // 释放锁（必须）
        }
    }
}

记住：使用显式锁时，必须在finally中释放锁。

否则一旦发生异常，锁可能无法释放。

4. 线程池：高效管理线程

频繁创建和销毁线程，开销很大。

线程池的作用，就是复用线程，提升执行效率。

Ja va里通常直接使用ExecutorService和Executors工具类。

固定大小线程池

import ja va.util.concurrent.ExecutorService;
import ja va.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 5个线程
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " is processing task.");
            });
        }
        executor.shutdown(); // 关闭线程池（不再接受新任务）
    }
}

缓存线程池

缓存线程池适合生命周期极短、数量可能快速增长的任务。

ExecutorService cachedPool = Executors.newCachedThreadPool();

线程池大小怎么定？

一般建议是CPU核心数的1~2倍，但具体还要看任务类型。

• CPU密集型任务，线程数不宜过多
• IO密集型任务，可以适当增加线程数
• 最终配置仍需通过实际压测来调整

5. 并发工具类：简化复杂场景

ja va.util.concurrent包中提供了很多实用工具类。

在复杂并发场景下，它们能显著减少手动同步的负担。

CountDownLatch

CountDownLatch可以让主线程等待多个子线程执行完毕后再继续。

import ja va.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3); // 需等待3个线程
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is working.");
                latch.countDown(); // 任务完成，计数减1
            }).start();
        }
        latch.await(); // 主线程等待计数归零
        System.out.println("All tasks are done.");
    }
}

Semaphore

Semaphore用于控制同时访问资源的线程数量，常见于限流场景。

import ja va.util.concurrent.Semaphore;

class ResourcePool {
    private final Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问
    
    public void useResource() {
        try {
            semaphore.acquire(); // 获取许可
            System.out.println(Thread.currentThread().getName() + " is using resource.");
            Thread.sleep(1000); // 模拟资源使用
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release(); // 释放许可
        }
    }
}

这两个工具类用好后，很多并发控制问题都能更轻松地解决。

6. 并发集合：线程安全的容器

在并发场景下，不建议再手动给HashMap加synchronized。

Ja va已经提供了更适合多线程环境的线程安全集合。

ConcurrentHashMap

ConcurrentHashMap是高并发场景下的常用选择，性能通常优于synchronized HashMap。

import ja va.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap map = new ConcurrentHashMap<>();
        map.put("key1", 1);
        map.put("key2", 2);
        System.out.println(map.get("key1")); // 输出1
    }
}

CopyOnWriteArrayList

CopyOnWriteArrayList适合读多写少的场景。

它在写操作时会复制新数组，因此读线程基本不会受到影响。

import ja va.util.concurrent.CopyOnWriteArrayList;

public class Main {
    public static void main(String[] args) {
        CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
        list.add("item1");
        list.add("item2");
        for (String item : list) {
            System.out.println(item); // 安全遍历
        }
    }
}

选对集合类型，往往能省去大量同步处理的麻烦。

7. 原子操作：无锁编程

如果只是简单的数值增减，很多时候并不需要加锁。

ja va.util.concurrent.atomic包中的原子类就可以完成这类操作，而且性能很好。

import ja va.util.concurrent.atomic.AtomicInteger;

class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // 原子递增
    }
    
    public int getCount() {
        return count.get();
    }
}

它的核心原理是利用CAS（比较并交换）来保证原子性，避免了锁带来的阻塞开销。

8. 调试与优化技巧

• IDE调试：IntelliJ IDEA或Eclipse都能查看线程状态，如运行、阻塞、等待，也能查看调用栈，方便定位死锁和竞争问题。
• 监控工具：JDK自带的jvisualvm可以实时监控线程池、CPU、内存，在调整线程池大小时很有帮助。
• 避免死锁：一个简单有效的原则是，所有线程获取锁的顺序保持一致，比如都先锁A再锁B，同时尽量缩短锁的持有时间。

把这些要点吃透，你在Ubuntu上搞Ja va多线程开发，就能做到既快又稳，兼顾性能和安全。