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

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() ❌ 错误！会在主线程执行
}

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();
}

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();
}

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);

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();

// 使用线程池管理并发
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);

// 错误示例：非原子操作
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++;
    }
}

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

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