Java之进程/线程、并发/并行与启动全过程

在很多Ja va开发者的日常工作中，进程与线程的区分总是绕不开的基础话题。JVM提供了一层跨平台的抽象，让Ja va的并发编程既有操作系统的影子，又有自己独特的实现套路。下面就直接切入正题，系统梳理一下Ja va中进程和线程的实现方式，以及并发与并行背后的技术细节。

Ja va进程 vs 线程

三种线程启动方式（Ja va实现）

1. 继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}
public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start(); // 正确启动方式
    // thread.run() ❌ 错误！会在主线程执行
}

2. 实现Runnable接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running: " + Thread.currentThread().getName());
    }
}
public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.start();
    // Lambda简化版
    new Thread(() -> System.out.println("Lambda thread")).start();
}

3. 实现Callable接口 + Future

class MyCallable implements Callable {
    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        return "Result from " + Thread.currentThread().getName();
    }
}
public static void main(String[] args) throws Exception {
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Future future = executor.submit(new MyCallable());
    System.out.println("Main thread working...");
    System.out.println(future.get()); // 阻塞获取结果
    executor.shutdown();
}

Ja va进程启动方式

1. 使用Runtime.exec()

Process process = Runtime.getRuntime().exec("ja va -version");
// 读取进程输出
try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(process.getInputStream()))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}
int exitCode = process.waitFor(); // 等待进程结束
System.out.println("Exit code: " + exitCode);

2. 使用ProcessBuilder（推荐）

ProcessBuilder pb = new ProcessBuilder("ja va", "-version");
pb.redirectErrorStream(true); // 合并错误流到输入流
Process process = pb.start();
// 读取输出
try (InputStream is = process.getInputStream();
     BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {
    reader.lines().forEach(System.out::println);
}
int exitCode = process.waitFor();

并发与并行在Ja va中的实现

并发实现：

// 使用线程池管理并发
ExecutorService pool = Executors.newFixedThreadPool(4);
for (int i = 0; i < 10; i++) {
    pool.execute(() -> {
        System.out.println("Concurrent task in " + Thread.currentThread().getName());
    });
}
pool.shutdown();

并行实现：

// 使用并行流利用多核
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = numbers.parallelStream() // 并行流
        .mapToInt(n -> n * 2)
        .sum();
System.out.println("Parallel sum: " + sum);

Ja va并发工具包（ja va.util.concurrent）

最佳实践与陷阱

线程安全策略

// 错误示例：非原子操作
private int counter = 0;
public void increment() { counter++; } // ❌ 非线程安全
// 正确方案1：使用原子类
private AtomicInteger atomicCounter = new AtomicInteger();
public void safeIncrement() { atomicCounter.incrementAndGet(); }
// 正确方案2：使用锁
private final Object lock = new Object();
public void lockedIncrement() {
    synchronized(lock) {
        counter++;
    }
}

避免死锁的四项原则

• 固定加锁顺序
• 使用尝试锁（tryLock）
• 设置超时时间
• 避免嵌套锁

线程池使用规范

// 推荐手动创建线程池
ExecutorService customPool = new ThreadPoolExecutor(
    4, // 核心线程数
    10, // 最大线程数
    60, TimeUnit.SECONDS, // 空闲线程存活时间
    new ArrayBlockingQueue<>(100), // 任务队列
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

Ja va虚拟线程（Loom项目 - Ja va 19+）

// 创建百万级虚拟线程
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 1_000_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
} // 自动关闭executor

特点：

• 轻量级（内存开销约2KB）
• 由JVM调度，非OS线程
• 适合I/O密集型任务
• 兼容现有Thread API

总结对比表

关键选择建议：

• 需要调用外部程序 → 使用ProcessBuilder
• CPU密集型计算 → 使用线程池+Callable
• I/O密集型任务 → 使用虚拟线程（Ja va19+）
• 线程间数据交换 → 使用ConcurrentHashMap/BlockingQueue
• 异步编程 → 使用CompletableFuture
• 定时任务 → 使用ScheduledThreadPoolExecutor

Ja va的并发API随着版本迭代持续增强，从最初的synchronized关键字，到ja va.util.concurrent工具包，再到Project Loom的虚拟线程，为开发者提供了越来越强大的并发编程能力。掌握这些工具的选择和使用时机，是构建高性能Ja va应用的关键。