最近在准备面试发现高并发和多线程相关的题目总是绕不开尤其是问到原理和实际应用时如果只停留在概念层面很容易被问住。无论是校招还是社招面试官都期望你能清晰地阐述核心概念并能结合实际场景分析问题。本文将系统梳理高并发与多线程面试中的核心知识点从基础概念、核心原理到经典面试题剖析并提供可运行的代码示例和排查思路帮助你构建完整的知识体系从容应对面试。1. 高并发与多线程核心概念解析在深入技术细节之前我们必须明确“高并发”和“多线程”这两个经常被一起提及但内涵不同的概念。理解它们的区别和联系是回答好面试问题的第一步。1.1 什么是高并发高并发High Concurrency通常指系统在短时间内处理大量请求的能力。这里的“并发”强调的是一种场景或状态即多个操作请求、任务在同一时间段内发生。关键指标包括QPSQueries Per Second每秒查询率衡量系统每秒能处理的请求数。TPSTransactions Per Second每秒事务数衡量系统每秒能处理的事务数。响应时间Response Time系统对请求作出响应的时间。并发用户数Concurrent Users同时与系统进行交互的用户数量。典型的高并发场景有电商秒杀、12306抢票、微博热点事件、即时通讯消息洪峰等。解决高并发问题的核心思路是垂直扩展提升单机能力和水平扩展增加机器数量并配合缓存、异步、队列等技术。1.2 什么是多线程多线程Multithreading是一种编程模型或技术手段指在一个进程内创建多个执行流线程这些线程共享进程的内存空间如堆、方法区但拥有独立的程序计数器、虚拟机栈和本地方法栈。多线程是实现并发编程的一种重要方式。它的主要目的是充分利用多核CPU让多个线程并行执行提升计算密集型任务的吞吐量。提高响应性对于IO密集型任务如网络请求、文件读写当一个线程阻塞在IO上时其他线程可以继续执行避免程序“卡死”。简化模型将复杂的异步回调逻辑用更直观的同步代码风格来编写虽然会引入同步问题。1.3 高并发与多线程的关系这是一个经典的面试题“高并发一定要用多线程吗” 答案是否定的。多线程是实现高并发的一种技术手段尤其在单机多核环境下。通过线程池管理大量线程可以有效处理并发请求。高并发还可以通过其他方式实现例如多进程如Nginx采用的多进程模型进程间隔离性好但通信成本高。异步非阻塞IO如Node.js、Netty使用单线程或少量线程配合事件循环Event Loop处理大量网络连接在IO密集型场景下效率极高。协程如Go语言的goroutinePython的asyncio是一种更轻量级的用户态线程切换开销小可以创建大量并发体。简单来说高并发是目标多线程是达成此目标的常用工具之一。面试中需要根据场景选择最合适的工具。2. 多线程编程核心线程安全与锁机制理解了为什么需要多线程接下来就要面对其带来的最大挑战线程安全问题。这是面试中深度考察的重点。2.1 线程安全的本质当多个线程访问同一个共享资源变量、对象、文件等且至少有一个线程在执行写操作时如果不采取同步措施就可能导致数据不一致、脏读、幻读等问题。线程安全的本质是保证共享资源在并发访问下的正确性。我们来看一个经典的线程不安全示例public class UnsafeCounter { private int count 0; public void add() { count; // 非原子操作 } public int get() { return count; } }count看似一行代码实际上对应了“读取-修改-写入”三个步骤。如果两个线程同时执行可能导致最终结果小于预期。2.2 Java内存模型JMM与可见性、原子性、有序性面试官常问“说说Java内存模型” 这关系到线程安全的底层原理。主内存与工作内存JMM规定所有变量存储在主内存每个线程有自己的工作内存线程对变量的操作都在工作内存中进行再同步回主内存。这导致了可见性问题一个线程修改了共享变量另一个线程可能无法立即看到。原子性一个或多个操作要么全部执行成功要么全部不执行中间不会被线程切换打断。count不是原子操作。有序性程序执行的顺序不一定等于代码编写的顺序编译器和处理器会进行指令重排序在单线程下遵循as-if-serial语义结果不变但在多线程下可能导致问题。2.3 Synchronized 关键字synchronized是Java内置的、最基础的互斥锁用于保证同一时刻只有一个线程能进入同步代码块或方法。public class SafeCounter { private int count 0; // 同步实例方法锁是当前对象实例(this) public synchronized void add() { count; } // 同步代码块可以指定锁对象更灵活 public void addWithBlock() { synchronized (this) { count; } } // 同步静态方法锁是当前类的Class对象 public static synchronized void staticAdd() { // ... } }面试要点锁对象 synchronized锁的是对象而不是代码。要保证线程安全所有竞争线程必须锁同一个对象。可重入性 同一个线程可以多次获取同一把锁防止死锁。锁升级 在JDK 1.6之后synchronized引入了偏向锁、轻量级锁、重量级锁的升级过程以减少性能开销。2.4 volatile 关键字volatile是轻量级的同步机制它主要解决可见性和有序性问题不保证原子性。可见性 对一个volatile变量的写操作会立即刷新到主内存对一个volatile变量的读操作会从主内存中读取最新值。禁止指令重排序 通过内存屏障实现。public class VolatileExample { private volatile boolean flag false; // 使用volatile保证可见性 public void writer() { flag true; // 写操作 } public void reader() { if (flag) { // 读操作能立即看到writer线程的修改 // do something } } }典型应用场景状态标志位如上例。DCLDouble-Checked Locking单例模式中修饰实例变量。面试陷阱“volatile能保证原子性吗” 答案是不能。volatile int a; a这样的操作依然不是线程安全的。2.5 JUCjava.util.concurrent包中的锁对于更复杂的并发控制synchronized显得力不从心。JUC包提供了更强大的工具。ReentrantLock可重入锁import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockCounter { private int count 0; private final ReentrantLock lock new ReentrantLock(); // 默认非公平锁 public void add() { lock.lock(); // 手动获取锁 try { count; } finally { lock.unlock(); // 必须在finally块中释放锁防止死锁 } } }与synchronized对比灵活性 可尝试非阻塞获取锁(tryLock)、可中断(lockInterruptibly)、可设置超时。公平性 可以创建公平锁先等待的线程先获得锁但性能通常低于非公平锁。条件变量 一个锁可以关联多个Condition实现更精细的线程等待/通知。ReadWriteLock读写锁适用于“读多写少”的场景允许多个线程同时读但写线程独占锁能大幅提升读性能。import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class CacheWithReadWriteLock { private MapString, Object cache new HashMap(); private final ReadWriteLock rwLock new ReentrantReadWriteLock(); public Object get(String key) { rwLock.readLock().lock(); // 获取读锁 try { return cache.get(key); } finally { rwLock.readLock().unlock(); } } public void put(String key, Object value) { rwLock.writeLock().lock(); // 获取写锁 try { cache.put(key, value); } finally { rwLock.writeLock().unlock(); } } }3. 并发编程核心工具类掌握了锁我们还需要更高级的工具来管理线程和任务协作。3.1 线程池ThreadPoolExecutor直接创建和销毁线程开销很大。线程池通过复用已创建的线程来执行任务是处理高并发请求的基石。核心参数面试必问corePoolSize 核心线程数即使空闲也会保留的线程数量。maximumPoolSize 最大线程数。workQueue 任务队列用于存放等待执行的任务。keepAliveTime 非核心线程空闲时的存活时间。threadFactory 线程工厂用于创建新线程。handler 拒绝策略当线程池和队列都满了如何处理新任务。创建与使用import java.util.concurrent.*; public class ThreadPoolDemo { public static void main(String[] args) { // 手动创建便于理解参数 ThreadPoolExecutor executor new ThreadPoolExecutor( 2, // corePoolSize 5, // maximumPoolSize 60L, TimeUnit.SECONDS, // keepAliveTime new LinkedBlockingQueue(10), // workQueue Executors.defaultThreadFactory(), // threadFactory new ThreadPoolExecutor.AbortPolicy() // handler ); // 提交任务 for (int i 0; i 15; i) { final int taskId i; executor.execute(() - { System.out.println(Thread.currentThread().getName() 执行任务: taskId); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }); } // 优雅关闭 executor.shutdown(); try { if (!executor.awaitTermination(60, TimeUnit.SECONDS)) { executor.shutdownNow(); } } catch (InterruptedException e) { executor.shutdownNow(); } } }Executors工具类谨慎使用Executors.newFixedThreadPool(n) 固定大小线程池队列无界可能堆积大量任务导致OOM。Executors.newCachedThreadPool() 可缓存线程池最大线程数为Integer.MAX_VALUE可能创建大量线程导致OOM。Executors.newSingleThreadExecutor() 单线程池保证任务顺序执行。Executors.newScheduledThreadPool(n) 定时任务线程池。面试建议 生产环境推荐手动创建ThreadPoolExecutor以便明确控制所有参数避免资源耗尽风险。3.2 并发集合Concurrent Collections传统的HashMap、ArrayList在多线程下是不安全的。JUC提供了高效的并发容器。ConcurrentHashMap 分段锁JDK 7或CASsynchronizedJDK 8及以后实现高并发读写。面试常问与Hashtable、Collections.synchronizedMap的区别Hashtable锁整个表性能差synchronizedMap使用对象锁性能也一般ConcurrentHashMap锁粒度更细并发度更高。CopyOnWriteArrayList 写时复制。修改时复制一个新数组在新数组上操作最后替换引用。适用于读多写极少的场景。ConcurrentLinkedQueue 基于CAS实现的无界非阻塞队列。BlockingQueue 阻塞队列是线程池任务队列的核心接口。常用实现有ArrayBlockingQueue有界、LinkedBlockingQueue可选有界、SynchronousQueue不存储元素等。3.3 原子类Atomic Classes基于CASCompare-And-Swap操作提供原子性的更新性能通常优于锁。import java.util.concurrent.atomic.AtomicInteger; public class AtomicCounter { private AtomicInteger count new AtomicInteger(0); public void add() { count.incrementAndGet(); // 原子性的 i // count.getAndIncrement(); // 原子性的 i } public int get() { return count.get(); } }CAS原理 “我认为V的值应该是A如果是那么将它更新为B否则不修改并告诉我当前值是多少。” 这是一个CPU原子指令。存在“ABA”问题一个值从A变成B又变回ACAS会误认为没变可以通过AtomicStampedReference带版本号解决。3.4 CountDownLatch、CyclicBarrier、SemaphoreCountDownLatch倒计时门闩 一个线程或多个等待其他一组线程完成操作。// 模拟主线程等待多个子线程加载完资源 CountDownLatch latch new CountDownLatch(3); // 计数3 for (int i 0; i 3; i) { new Thread(() - { // 模拟加载 System.out.println(Thread.currentThread().getName() 加载完成); latch.countDown(); // 计数减1 }).start(); } latch.await(); // 主线程等待直到计数为0 System.out.println(所有资源加载完毕主程序启动);CyclicBarrier循环栅栏 一组线程互相等待到达一个公共屏障点后再同时继续执行。可重复使用。// 模拟多个线程到达集合点后一起出发 CyclicBarrier barrier new CyclicBarrier(3, () - System.out.println(所有线程已就位同时出发)); for (int i 0; i 3; i) { new Thread(() - { System.out.println(Thread.currentThread().getName() 到达集合点); try { barrier.await(); // 等待其他线程 } catch (Exception e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() 开始执行任务); }).start(); }Semaphore信号量 控制同时访问特定资源的线程数量用于流量控制。// 模拟只有3个许可的数据库连接池 Semaphore semaphore new Semaphore(3); for (int i 0; i 10; i) { new Thread(() - { try { semaphore.acquire(); // 获取许可 System.out.println(Thread.currentThread().getName() 获取连接执行查询...); Thread.sleep(2000); // 模拟操作 } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(Thread.currentThread().getName() 释放连接); semaphore.release(); // 释放许可 } }).start(); }4. 经典面试场景实战剖析理论结合实践下面我们通过几个经典面试题场景串联起上述知识点。4.1 场景一实现一个线程安全的单例模式这是考察对线程安全、内存模型、类加载机制理解的经典题目。懒汉式双重检查锁定 - DCLpublic class Singleton { // volatile 防止指令重排序保证可见性 private static volatile Singleton instance; private Singleton() {} // 私有构造 public static Singleton getInstance() { if (instance null) { // 第一次检查避免不必要的同步 synchronized (Singleton.class) { // 类锁 if (instance null) { // 第二次检查确保唯一性 instance new Singleton(); // 非原子操作1.分配内存 2.初始化 3.引用赋值 } } } return instance; } }要点volatile关键字在此至关重要。因为instance new Singleton()不是原子操作可能发生重排序导致其他线程拿到一个未初始化完全的对象。饿汉式基于类加载机制public class Singleton { // 类加载时即初始化由JVM保证线程安全 private static final Singleton INSTANCE new Singleton(); private Singleton() {} public static Singleton getInstance() { return INSTANCE; } }要点 简单、线程安全但非懒加载如果实例创建依赖参数或资源则不适用。静态内部类式推荐public class Singleton { private Singleton() {} // 静态内部类在第一次被引用时才加载其INSTANCE由JVM保证唯一性 private static class Holder { private static final Singleton INSTANCE new Singleton(); } public static Singleton getInstance() { return Holder.INSTANCE; } }要点 结合了懒加载和线程安全且实现简洁是常用的推荐写法。4.2 场景二生产者-消费者模型考察对线程间协作、阻塞队列、锁和条件变量的理解。使用BlockingQueue实现最简单import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class ProducerConsumerWithBlockingQueue { private static BlockingQueueInteger queue new LinkedBlockingQueue(10); // 容量10 static class Producer implements Runnable { Override public void run() { try { int value 0; while (true) { queue.put(value); // 队列满时会阻塞 System.out.println(生产: value); value; Thread.sleep(100); // 模拟生产耗时 } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } static class Consumer implements Runnable { Override public void run() { try { while (true) { Integer value queue.take(); // 队列空时会阻塞 System.out.println(消费: value); Thread.sleep(200); // 模拟消费耗时 } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } public static void main(String[] args) { new Thread(new Producer()).start(); new Thread(new Consumer()).start(); } }使用Lock和Condition实现理解底层import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ProducerConsumerWithLockCondition { private final Lock lock new ReentrantLock(); private final Condition notFull lock.newCondition(); // 队列未满条件 private final Condition notEmpty lock.newCondition(); // 队列非空条件 private final Integer[] items new Integer[10]; private int putPtr, takePtr, count; public void put(Integer x) throws InterruptedException { lock.lock(); try { while (count items.length) { // 队列满等待“未满”信号 notFull.await(); } items[putPtr] x; if (putPtr items.length) putPtr 0; // 环形队列 count; notEmpty.signal(); // 生产了一个通知消费者可以取了 } finally { lock.unlock(); } } public Integer take() throws InterruptedException { lock.lock(); try { while (count 0) { // 队列空等待“非空”信号 notEmpty.await(); } Integer x items[takePtr]; if (takePtr items.length) takePtr 0; --count; notFull.signal(); // 消费了一个通知生产者可以放了 return x; } finally { lock.unlock(); } } }4.3 场景三模拟12306抢票中的超卖问题这是一个典型的高并发写场景。核心问题是如何保证库存扣减的原子性错误示例线程不安全public class UnsafeTicketSeller { private int ticketCount 100; // 100张票 public boolean sellTicket() { if (ticketCount 0) { // 模拟业务处理耗时 try { Thread.sleep(10); } catch (InterruptedException e) {} ticketCount--; System.out.println(Thread.currentThread().getName() 卖出一张票剩余: ticketCount); return true; } return false; } } // 多个线程同时调用sellTicket()会导致超卖卖出超过100张解决方案1使用synchronizedpublic synchronized boolean sellTicket() { // ... 方法体不变 }解决方案2使用ReentrantLockprivate final Lock lock new ReentrantLock(); public boolean sellTicket() { lock.lock(); try { // ... 方法体不变 } finally { lock.unlock(); } }解决方案3使用原子类适合简单计数private AtomicInteger ticketCount new AtomicInteger(100); public boolean sellTicket() { int current; do { current ticketCount.get(); if (current 0) { return false; } } while (!ticketCount.compareAndSet(current, current - 1)); // CAS操作 System.out.println(Thread.currentThread().getName() 卖出一张票剩余: ticketCount.get()); return true; }要点 在分布式环境下单机的锁或原子类就失效了需要借助分布式锁如Redis、ZooKeeper或利用数据库的乐观锁、悲观锁机制。5. 高级主题与常见面试题深度解析5.1 ThreadLocal原理与应用ThreadLocal提供了线程局部变量每个线程都有自己独立的变量副本避免了共享变量带来的线程安全问题。原理 每个Thread对象内部都有一个ThreadLocalMap以ThreadLocal自身为Key存储变量副本。public class ThreadLocalDemo { private static ThreadLocalInteger threadLocalValue ThreadLocal.withInitial(() - 0); public static void main(String[] args) { for (int i 0; i 3; i) { new Thread(() - { int value threadLocalValue.get(); threadLocalValue.set(value 1); System.out.println(Thread.currentThread().getName() : threadLocalValue.get()); // 使用完后必须remove尤其是在线程池环境中防止内存泄漏 threadLocalValue.remove(); }).start(); } } }内存泄漏风险ThreadLocalMap的Key是弱引用但Value是强引用。如果线程长期运行如线程池线程且不调用remove()Key会被回收但Value依然存在导致内存泄漏。最佳实践务必在try-finally块中使用并在finally中调用remove()。5.2 死锁Deadlock与排查死锁是指两个或以上的线程在执行过程中因争夺资源而造成的一种互相等待的现象。死锁产生的四个必要条件面试常问互斥条件资源一次只能被一个线程占用。请求与保持条件一个线程因请求资源而阻塞时对已获得的资源保持不放。不剥夺条件线程已获得的资源在未使用完之前不能被强行剥夺。循环等待条件若干线程之间形成一种头尾相接的循环等待资源关系。死锁示例public class DeadLockDemo { private static Object lockA new Object(); private static Object lockB new Object(); public static void main(String[] args) { new Thread(() - { synchronized (lockA) { System.out.println(Thread1 got lockA); try { Thread.sleep(50); } catch (InterruptedException e) {} synchronized (lockB) { System.out.println(Thread1 got lockB); } } }).start(); new Thread(() - { synchronized (lockB) { System.out.println(Thread2 got lockB); try { Thread.sleep(50); } catch (InterruptedException e) {} synchronized (lockA) { System.out.println(Thread2 got lockA); } } }).start(); } }如何排查死锁使用jstack命令jstack -l pid可以查看线程堆栈信息会明确提示找到的死锁。使用JConsole或VisualVM 图形化工具可以检测到死锁。代码层面预防避免嵌套锁。按固定顺序获取锁对所有锁进行排序所有线程都按相同顺序申请。使用带超时的锁如tryLock。5.3 并发编程三大问题综合案例结合一个简单案例分析原子性、可见性、有序性问题。public class ConcurrencyProblem { private int a 0; private boolean flag false; public void writer() { a 1; // 操作1 flag true; // 操作2 } public void reader() { if (flag) { // 操作3 int i a * a; // 操作4 // i 可能等于0吗 } } }假设线程A执行writer()线程B执行reader()。由于指令重排序操作1和操作2的顺序可能颠倒。如果线程B看到flag为true时操作3操作1可能还未执行那么i就可能为0。此外即使没有重排序由于可见性问题线程B也可能看不到线程A对a的修改。解决方案 将flag声明为volatile可以防止重排序并保证可见性。或者将两个方法都设为synchronized。6. 面试高频问题与回答思路synchronized和ReentrantLock的区别本质synchronized是JVM关键字ReentrantLock是JDK类。锁的获取与释放synchronized自动释放ReentrantLock需手动lock/unlock。响应中断synchronized等待不可中断ReentrantLock可用lockInterruptibly()响应中断。公平锁synchronized非公平ReentrantLock可公平可非公平。条件变量synchronized通过wait/notify一个锁一个条件ReentrantLock可绑定多个Condition。性能在高度竞争下ReentrantLock性能可能更好低竞争下synchronized有优化优势。volatile关键字的作用能保证原子性吗作用保证可见性禁止指令重排序。不能保证原子性。对于复合操作如i仍需借助synchronized或原子类。ThreadLocal原理内存泄漏问题原理每个Thread内部有ThreadLocalMap以ThreadLocal为Key存储值。内存泄漏Key是弱引用Value是强引用。线程不终止且不removeValue会一直存在。解决用完后必须调用remove()。线程池核心参数与工作流程核心参数corePoolSize, maximumPoolSize, workQueue, keepAliveTime, threadFactory, handler。工作流程提交任务 - 核心线程未满创建核心线程执行 : 入队成功入队 : 最大线程未满创建非核心线程执行 : 执行拒绝策略。ConcurrentHashMap原理JDK 1.7 vs 1.8JDK 1.7分段锁Segment锁住一段哈希桶。JDK 1.8数组链表/红黑树使用CASsynchronized锁住单个链表头节点Node锁粒度更细。CAS是什么ABA问题CASCompare And Swap一种乐观锁CPU原子指令。包含三个操作数内存位置V预期原值A新值B。当且仅当VA时才将V更新为B。ABA问题一个值从A变成B又变回ACAS检查时会认为没变。解决方案使用AtomicStampedReference添加版本戳。什么是AQSAQSAbstractQueuedSynchronizer是JUC锁框架的核心。它用一个int类型的state表示同步状态并通过一个FIFO队列管理获取锁失败的线程。ReentrantLock、CountDownLatch、Semaphore等都是基于AQS实现的。7. 最佳实践与避坑指南尽量使用高层并发工具 优先选择java.util.concurrent包下的类如ConcurrentHashMap,ExecutorService,CountDownLatch而不是自己从0开始用synchronized和wait/notify造轮子。明确锁的范围 锁的粒度要尽可能小只锁住必要的共享数据以提升并发度。预防死锁 使用定时锁tryLock避免锁的嵌套设计锁的获取顺序。关闭资源与异常处理 在finally块中释放锁、关闭IO连接、调用ThreadLocal.remove()。避免在持有锁时调用外部方法 外部方法可能耗时、可能再获取其他锁容易导致死锁或性能问题。谨慎使用线程优先级 优先级设置依赖于操作系统行为不一致不要用它来控制业务逻辑。考虑使用并发编程框架 对于复杂并发逻辑可以考虑使用AkkaActor模型、RxJava响应式编程等框架。性能测试与监控 多线程程序一定要进行压力测试并使用Profiler工具如Arthas, JProfiler监控线程状态、锁竞争、死锁等情况。掌握高并发与多线程不仅仅是背会八股文更重要的是理解其背后的原理并能在实际场景中做出合理的设计和选择。建议在理解本文知识点的同时多动手编写和调试代码观察不同条件下的程序行为这样才能在面试和实际工作中游刃有余。