首页 > 软件编程 > java > Java进程/线程、并发/并行与启动

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

2026-06-17 11:44:59 作者：起名字真的好麻烦啊啊啊Ｏ(≧口≦)Ｏ

这段描述强调了Java中进程与线程的实现方式及其特性,涵盖了进程和线程的创建方式、内存模型、通信机制、资源消耗以及故障影响等多个方面,同时介绍了Java特有的线程池、Callable接口、Java并发工具包等关键技术细节,帮助开发者更好地理解和利用Java的并发编程能力

在Java中，进程和线程的实现与底层操作系统交互，但通过JVM提供了跨平台的抽象层。

下面补充Java特有的实现方式和技术细节。

Java进程 vs 线程

特性	进程	线程
创建方式	ProcessBuilder/Runtime.exec()	继承Thread或实现Runnable
内存模型	独立JVM实例	共享堆内存，线程栈独立
通信机制	套接字、文件、IPC	共享变量、阻塞队列、同步器
资源开销	高（独立JVM）	低（轻量级）
故障影响	进程崩溃不影响其他进程	线程异常可能导致整个JVM退出

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

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<String> {
    @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<String> future = executor.submit(new MyCallable());
    System.out.println("Main thread working...");
    System.out.println(future.get()); // 阻塞获取结果
    executor.shutdown();
}

Java进程启动方式

1. 使用Runtime.exec()

Process process = Runtime.getRuntime().exec("java -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("java", "-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();

并发与并行在Java中的实现

并发实现：

// 使用线程池管理并发
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<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = numbers.parallelStream() // 并行流
        .mapToInt(n -> n * 2)
        .sum();
System.out.println("Parallel sum: " + sum);

Java并发工具包（java.util.concurrent）

工具类型	代表类	用途
线程池	ThreadPoolExecutor	管理线程生命周期
同步集合	ConcurrentHashMap	高并发安全集合
原子变量	AtomicInteger	无锁线程安全操作
锁机制	ReentrantLock	替代synchronized的高级锁
同步辅助类	CountDownLatch, CyclicBarrier	多线程协调工具
异步计算	CompletableFuture	链式异步编程

最佳实践与陷阱

线程安全策略

// 错误示例：非原子操作
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() // 拒绝策略
);

Java虚拟线程（Loom项目 - Java 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

总结对比表

特性	C/C++实现	Java实现
进程创建	fork()	ProcessBuilder/Runtime.exec()
线程创建	pthread_create()	Thread/Runnable/Callable
进程通信	管道/共享内存	Socket/文件/内存映射文件
线程同步	pthread_mutex	synchronized/Lock/Atomic
并发模型	手动管理	Executor框架/CompletableFuture
内存隔离	进程级隔离	JVM进程内线程共享

关键选择建议：

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

Java的并发API随着版本迭代持续增强，从最初的synchronized关键字，到java.util.concurrent工具包，再到Project Loom的虚拟线程，为开发者提供了越来越强大的并发编程能力。

掌握这些工具的选择和使用时机，是构建高性能Java应用的关键。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。