Java面试并发问题解析｜高频考点·原理详解·实战案例·避坑指南

// 创建线程的三种方式对比
public class ThreadCreationDemo {
    // 方式1：继承Thread类（不推荐，单继承限制）
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread: " + Thread.currentThread().getName());
        }
    }
    // 方式2：实现Runnable接口（推荐，解耦任务与线程）
    static class MyTask implements Runnable {
        @Override
        public void run() {
            System.out.println("MyTask: " + Thread.currentThread().getName());
        }
    }
    // 方式3：Lambda + Thread（现代写法）
    public static void main(String[] args) {
        new MyThread().start();
        new Thread(new MyTask()).start();
        new Thread(() -> System.out.println("Lambda: " + Thread.currentThread().getName())).start();
    }
}

public class Counter {
    private int count = 0;
    public void increment() {
        count++; // 问题！
    }
    public int getCount() {
        return count;
    }
}

// 错误示例：volatile无法解决i++的原子性
public class VolatileCounter {
    private volatile int count = 0;
    public void increment() {
        count++; // 仍可能丢失更新！
    }
}

// 正确示例：volatile用于状态标记
public class Worker implements Runnable {
    private volatile boolean running = true;
    @Override
    public void run() {
        while (running) {
            // 执行任务...
        }
    }
    public void stop() {
        running = false; // 确保其他线程可见
    }
}

// 错误写法：可能返回未完全初始化的对象
public class Singleton {
    private static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton(); // 问题：指令重排序！
                }
            }
        }
        return instance;
    }
}

public class Singleton {
    private static volatile Singleton instance; // 关键：volatile
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// ReentrantLock非公平锁tryAcquire源码简化版
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) { // 无锁状态
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) { // 重入
        int nextc = c + acquires;
        setState(nextc);
        return true;
    }
    return false;
}

// 安全的异常处理示例
ExecutorService pool = Executors.newFixedThreadPool(10);
Future future = pool.submit(() -> {
    // 业务逻辑...
    throw new RuntimeException("模拟异常");
});
try {
    future.get(); // 捕获异常
} catch (ExecutionException e) {
    System.err.println("任务执行失败：" + e.getCause().getMessage());
}

// 典型使用：注册监听器
private final CopyOnWriteArrayList listeners = new CopyOnWriteArrayList<>();
public void addListener(Runnable listener) {
    listeners.add(listener);
}
public void notifyListeners() {
    for (Runnable listener : listeners) {
        listener.run(); // 读操作无锁，安全
    }
}