当前位置：首页 > wzjs >正文

一站式媒体发布平台国家免费职业技能培训官网

wzjs 2025/9/23 3:30:59

一站式媒体发布平台,国家免费职业技能培训官网,金山做企业网站,免费服务器空间申请一、前言：并发编程的重要性在多核处理器成为主流的今天，并发编程能力已成为衡量Java工程师水平的重要标准。据统计，超过80%的中高级Java岗位面试都会深入考察并发编程知识。今天我们将系统梳理Java并发编程的核心考点，帮助你从容…

一、前言：并发编程的重要性

在多核处理器成为主流的今天，并发编程能力已成为衡量Java工程师水平的重要标准。据统计，超过80%的中高级Java岗位面试都会深入考察并发编程知识。今天我们将系统梳理Java并发编程的核心考点，帮助你从容应对面试挑战。

二、线程基础与生命周期

2.1 线程状态转换图

NEW → RUNNABLE ↔ RUNNING↓               ↑
TERMINATED ← BLOCKED/WATING/TIMED_WAITING

2.2 线程状态详解

状态	触发条件	特点
NEW	刚创建未start()	未启动
RUNNABLE	调用start()	可运行状态
BLOCKED	等待监视器锁	同步阻塞
WAITING	wait()/join()	无限期等待
TIMED_WAITING	sleep(n)/wait(n)	超时等待
TERMINATED	执行完毕	线程结束

2.3 创建线程的三种方式

// 1. 继承Thread类
class MyThread extends Thread {public void run() {System.out.println("Thread running");}
}// 2. 实现Runnable接口
class MyRunnable implements Runnable {public void run() {System.out.println("Runnable running");}
}// 3. 实现Callable接口（可获取返回值）
class MyCallable implements Callable<String> {public String call() throws Exception {return "Callable result";}
}// 使用示例
public static void main(String[] args) throws Exception {new MyThread().start();new Thread(new MyRunnable()).start();FutureTask<String> futureTask = new FutureTask<>(new MyCallable());new Thread(futureTask).start();System.out.println(futureTask.get());
}

三、线程同步与锁机制

3.1 synchronized实现原理

对象内存布局：

| Mark Word (32/64bit) | Class Pointer | Instance Data | Padding |

锁升级过程：
无锁 → 偏向锁 → 轻量级锁 → 重量级锁

3.2 ReentrantLock vs synchronized

特性	ReentrantLock	synchronized
实现方式	API层面	JVM层面
锁获取	可尝试获取tryLock()	阻塞获取
公平性	可配置公平/非公平	非公平
条件变量	支持多个Condition	单一wait/notify
中断响应	lockInterruptibly()	不支持
性能	高竞争下更优	低竞争下更优

3.3 volatile关键字

内存语义：

可见性：写操作立即刷新到主内存
禁止指令重排序

适用场景：

状态标志位
双重检查锁定（DCL）

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

四、并发工具类

4.1 AQS（AbstractQueuedSynchronizer）

核心结构：

state：同步状态
CLH队列：等待队列

基于AQS的实现类：

ReentrantLock
CountDownLatch
Semaphore
ReentrantReadWriteLock

4.2 CountDownLatch使用示例

public class CountDownLatchDemo {public static void main(String[] args) throws InterruptedException {CountDownLatch latch = new CountDownLatch(3);new Thread(() -> {System.out.println("Task 1 done");latch.countDown();}).start();new Thread(() -> {System.out.println("Task 2 done");latch.countDown();}).start();new Thread(() -> {System.out.println("Task 3 done");latch.countDown();}).start();latch.await();System.out.println("All tasks completed");}
}

4.3 ThreadLocal原理与内存泄漏

实现原理：
每个Thread维护一个ThreadLocalMap，key为弱引用的ThreadLocal实例

public class ThreadLocal<T> {public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);}// 使用后必须remove()避免内存泄漏public void remove() {ThreadLocalMap m = getMap(Thread.currentThread());if (m != null)m.remove(this);}
}

五、线程池深度解析

5.1 ThreadPoolExecutor核心参数

public ThreadPoolExecutor(int corePoolSize,      // 核心线程数int maximumPoolSize,   // 最大线程数long keepAliveTime,    // 空闲线程存活时间TimeUnit unit,         // 时间单位BlockingQueue<Runnable> workQueue, // 工作队列ThreadFactory threadFactory,       // 线程工厂RejectedExecutionHandler handler   // 拒绝策略
)

5.2 工作流程

提交任务
核心线程未满 → 创建新线程
核心线程已满 → 入队
队列已满且线程未达最大值 → 创建非核心线程
线程已达最大值 → 执行拒绝策略

5.3 四种拒绝策略

策略	实现类	行为
直接拒绝	AbortPolicy	抛出RejectedExecutionException
调用者运行	CallerRunsPolicy	由提交线程执行任务
丢弃最老	DiscardOldestPolicy	丢弃队列头任务并重试
静默丢弃	DiscardPolicy	直接丢弃不通知

六、高频面试题解析

6.1 问题1：synchronized和ReentrantLock的区别？

参考答案：

实现层面：synchronized是JVM层面，ReentrantLock是JDK代码
功能特性：
- ReentrantLock支持公平锁、可中断、超时等待
- synchronized使用更简单
性能：JDK6优化后性能接近，高竞争下ReentrantLock更优
锁释放：synchronized自动释放，ReentrantLock需手动unlock()

6.2 问题2：线程池队列满时的处理策略？

解决方案：

增大队列容量（如使用无界队列，风险：可能OOM）
增加最大线程数
优化任务处理时间
选择合适的拒绝策略：
- 重要任务：CallerRunsPolicy
- 可丢弃任务：DiscardOldestPolicy

七、实战编码题

题目：实现生产者-消费者模式

public class ProducerConsumer {private static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);static class Producer implements Runnable {public void run() {try {for (int i = 0; i < 100; i++) {queue.put(i);System.out.println("Produced: " + i);Thread.sleep(100);}} catch (InterruptedException e) {e.printStackTrace();}}}static class Consumer implements Runnable {public void run() {try {while (true) {Integer item = queue.take();System.out.println("Consumed: " + item);Thread.sleep(200);}} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {new Thread(new Producer()).start();new Thread(new Consumer()).start();}
}