Java面试技巧：如何回答多线程与并发问题？

引言

在Java技术面试中，多线程与并发问题几乎是必考内容。面试官通过这类问题考察候选人对Java内存模型、线程安全、锁机制等核心概念的理解程度。本文将深入剖析常见的多线程面试问题，并提供高质量的代码示例和回答策略，帮助你在面试中脱颖而出。

一、理解Java内存模型(JMM)

1.1 JMM基础概念

Java内存模型定义了线程如何与内存交互，它规定了：

• 共享变量存储在主内存中
• 每个线程有自己的工作内存
• 线程间通信通过主内存完成

// 可见性问题示例
public class VisibilityProblem {
    private static boolean flag = true;
    
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag) {}  // 可能永远循环
            System.out.println("Thread stopped");
        }).start();
        
        Thread.sleep(1000);
        flag = false;
        System.out.println("Main thread set flag to false");
    }
}

1.2 volatile关键字解析

volatile解决了可见性和有序性问题：

• 保证变量的修改立即写入主内存
• 禁止指令重排序优化

// 正确使用volatile
public class VolatileExample {
    private volatile boolean flag = true;
    
    public void stop() {
        flag = false;
    }
    
    public void doWork() {
        while (flag) {
            // 正常工作
        }
    }
}

二、线程安全的核心实现方式

2.1 synchronized关键字

synchronized是最基本的线程安全实现方式：

• 修饰实例方法：锁定当前实例
• 修饰静态方法：锁定类对象
• 修饰代码块：指定锁对象

// 双重检查锁定单例模式
public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2.2 Lock接口及其实现

相比synchronized，Lock提供了更灵活的锁操作：

// ReentrantLock使用示例
public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

三、并发工具类详解

3.1 CountDownLatch应用

允许一个或多个线程等待其他线程完成操作：

// 并行任务处理示例
public class ParallelProcessor {
    public void process(List<Runnable> tasks) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(tasks.size());
        
        for (Runnable task : tasks) {
            new Thread(() -> {
                try {
                    task.run();
                } finally {
                    latch.countDown();
                }
            }).start();
        }
        
        latch.await();
        System.out.println("All tasks completed");
    }
}

3.2 ConcurrentHashMap原理

分段锁实现高并发：

// 线程安全的缓存实现
public class Cache<K, V> {
    private final ConcurrentHashMap<K, V> map = new ConcurrentHashMap<>();
    
    public V get(K key) {
        return map.get(key);
    }
    
    public void put(K key, V value) {
        map.put(key, value);
    }
    
    public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
        return map.computeIfAbsent(key, mappingFunction);
    }
}

四、线程池深度解析

4.1 线程池参数配置

核心参数理解：

• corePoolSize：核心线程数
• maximumPoolSize：最大线程数
• keepAliveTime：空闲线程存活时间
• workQueue：任务队列

// 自定义线程池示例
public class CustomThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2,  // 核心线程数
            4,  // 最大线程数
            60, // 空闲时间
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(10), // 任务队列
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
        
        // 提交任务
        for (int i = 0; i < 15; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Executing task " + taskId + " in " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        executor.shutdown();
    }
}

4.2 线程池监控与调优

通过扩展ThreadPoolExecutor实现监控：

public class MonitorableThreadPool extends ThreadPoolExecutor {
    public MonitorableThreadPool(int corePoolSize, int maximumPoolSize, 
                                long keepAliveTime, TimeUnit unit,
                                BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        System.out.println("Task started in " + t.getName());
    }
    
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        System.out.println("Task completed in " + Thread.currentThread().getName());
    }
}

五、常见面试问题与回答策略

5.1 如何避免死锁？

回答策略：

1. 解释死锁的四个必要条件
2. 提供避免死锁的方法
3. 给出代码示例

// 死锁示例与避免
public class DeadlockAvoidance {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    // 容易导致死锁的方式
    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 操作共享资源
            }
        }
    }
    
    // 避免死锁的方式：固定加锁顺序
    public void method2() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 操作共享资源
            }
        }
    }
    
    // 使用tryLock避免死锁
    public void method3() {
        boolean gotLock1 = false;
        boolean gotLock2 = false;
        try {
            gotLock1 = ((ReentrantLock) lock1).tryLock();
            gotLock2 = ((ReentrantLock) lock2).tryLock();
            if (gotLock1 && gotLock2) {
                // 操作共享资源
            }
        } finally {
            if (gotLock1) ((ReentrantLock) lock1).unlock();
            if (gotLock2) ((ReentrantLock) lock2).unlock();
        }
    }
}

5.2 synchronized和ReentrantLock的区别

回答策略：

1. 从实现机制对比
2. 功能特性对比
3. 性能差异
4. 使用场景建议

结语

掌握Java多线程与并发知识需要理论结合实践。面试时，除了正确回答问题，更要展示出你对问题本质的理解和解决复杂并发问题的能力。建议在准备面试时，不仅要阅读相关理论，还要动手编写并调试各种并发场景的代码，这样才能在面试中游刃有余。