⭐乐观锁与悲观锁
乐观锁与悲观锁的区别？
- 悲观锁：共享资源每次只给一个线程使用，其他线程阻塞，用完之后再把资源让给其他资源。但是读写锁可以多个线程同时读。
- 乐观锁：共享资源每次可以给多个线程使用，只是再提交修改的时候去验证资源是否被其他线程所修改。
使用场景：
- 悲观锁：适合写多读少的情况。
- 乐观锁：适合读多写少的情况。
缺陷：
- 悲观锁：高并发下，激烈的锁竞争会造成线程阻塞，大量的线程会导致系统上下文切换频繁，增加系统的性能开销；还有可能导致死锁。
- 乐观锁：高并发下，相比悲观锁来所，不存在锁竞争造成线程阻塞，也不会有死锁问题，性能往往更好。但是再写冲突高的场景下可能会导致ABA问题，性能忽高忽低等
CAS了解吗？原理是什么？
乐观锁一般会使用版本号机制或者CAS算法实现，CAS算法使用会多一些。值得一提的是，这里的版本号机制和CAS算法中的ABA问题的解决方案是同一个东西。
CAS算法的思想很简单，就是用一个预期值和要更新的变量值进行比较，两个值相等才会进行更新。这里的比较和修改两个步骤再CPU硬件层面是一条原子指令，是不可拆分的，这也是CAS算法的基础。
比如ConcurrentHashMap采用的就是CAS和synchronized来保证并发安全的。
原子类也是
⭐JMM（Java memory model）
并发编程的三个重要特性
- 原子性：一个或者多个操作要么全部执行且不中断，要么全部不执行。
- 可见性：当一个线程修改了共享变量，其他线程能够立刻看到这个修改。
- 有序性：编译器优化和指令重排在多线程情况下，可能导致意外的结果。因此保证有序性可以禁止指令进行重排序优化。
实现手段
- 原子性：一般都是通过加锁去实现，当然也可以使用CAS实现。
- 可见性：
- 使用
volatile关键字 synchronized和lock同步块final关键字再构造函数中有正确初始化(没有this逃逸)
- 使用
- 有序性：
volatilesynchronized和lock同步块happens-before原则:在多线程环境中，当两个操作之间存在happens-before关系时，前一个操作的修改对后一个操作是可见的。
什么是JMM？为什么需要JMM？
要了解JMM，就要了解计算机内存的发展史。
- 第一阶段：cpu从磁盘中读取数据，但是读取的速度太慢，使其cpu的性能大大浪费；
- 第二阶段：再cpu和磁盘中间增加了内存（主存），用以加快读取过程，但此时cpu的性能依旧没有得到充分的利用；
- 第三阶段：给cpu里面增加了缓存（一级、二级、三级），使其读取速度非常高。但是带来了缓存一致性的问题。
了解缓存一致性问题：
- 情况一：一个线程修改了缓存但是没有同步到主存，其他的cpu核心再去读取数据就是读取的脏数据，这也是可见性的本质。
- 情况二：再执行代码的时候，cpu或者编译器可能会对指令进行重新排序，导致执行的顺序和代码的顺序不一致。这只能保证单线程串行执行的语义一致，但是没有办法保证多线程并发执行的语义一致，这也是有序性的本质。
- 情况三：线程A读取到的库存为1，要进行减1的操作，但是只是读取到了还没执行，cpu时间片用完了。此时线程B拿到库存减1，将库存边为了0。当线程A回来执行的时候，再减1，此时的库存为-1。不符合预期，库存不能为负数，这也是原子性的本质。
所以整个并发编程的核心就是要去解决可见性、有序性、原子性问题。操作系统为了去解决这些问题，定义了一些规范。但是不同的操作模型内存模型是不同的。如果Java直接服用操作模型的内存模型去解决这些问题，就可能会导致同一套代码在不同的系统上可能运行结果不一样。但是Java的口号就是一次编译处处运行，所以Java就自己去提供了一套内存模型去屏蔽不同操作系统的差异。
JMM是如何抽象线程和主内存之间的关系？
知道了为什么需要JMM，那JMM是如何去解决这些问题的呢？JMM定义了一套并发编程相关的规范，抽离了缓存、线程、主存之间的关系去解决这些问题。
具体抽象过程：
┌─────────────┐ ┌─────────────┐
│ 线程1 │ │ 线程2 │
│ ┌─────────┐ │ │ ┌─────────┐ │
│ │本地内存 │ │ │ │本地内存 │ │
│ │ ┌────┐ │ │ │ │ ┌────┐ │ │
│ │ │共享│ │ │ │ │ │共享│ │ │
│ │ │变量│ │ │ │ │ │变量│ │ │
│ │ │副本│ │ │ │ │ │副本│ │ │
│ │ └────┘ │ │ │ │ └────┘ │ │
│ └─────────┘ │ │ └─────────┘ │
└──────┬──────┘ └──────┬──────┘
│ │
└────────────┬─────────────────┘
│
┌──────────▼──────────┐
│ 主内存 │
│ ┌──────┬──────┬──────┐
│ │共享 │共享 │共享 │
│ │变量1 │变量2 │变量3 │
│ └──────┴──────┴──────┘
└─────────────────────┘
- 将寄存器、cpu缓存这些东西统一抽象为线程的工作内存（本地内存），这是线程私有的一个计算区域，每个线程的工作内存相互独立。线程必须把主存中的数据读取到自己的工作内存中去计算，要与其他线程共享数据时，必须将计算后的结果刷新回主存中，其他线程再去读取。
- 抽象完成之后，就需要去定义工作内存和主内存之间要怎么进行交互。JMM规定了八种主存和工作内存之间的交互方式，如
lock、unlock、read等。 - 虽然定义了交互的方式，但是没有定义什么时候做，具体怎么实现顺序的保障。所以JMM需要通过内存屏障去保证交互的顺序性和可见性。这是一种cpu指令，主要有四种，都是为了禁止重排序。
- 但是从程序员写代码的角度来看，还是不知道编译器和处理器是怎么重排序的，怎么优化的。不知道实际的执行顺序就不知道线程A做的操作，线程B是否可见。因此JMM规定了happens-before规则（有八条），这个一个可见性的逻辑抽象，它不管底层是怎么实现的，只管 A happens before B，那么A的结果对B一定是可见的。
在知道happens-before规则时候，只需要知道操作满足规则，那就有顺序性的保证，那就是可见的。否则JVM就可以对指令进行重排序。
synchronized是什么？怎么使用？
synchronized是个锁，使这段代码同一时间只能被一个线程访问，这就是原子性。它编译之后就是monitor enter 和 monitor exit 两个指令。enter就是加锁，加锁的时候会使用读屏障，强行从主存中重新读取数据。exit是解锁，解锁的时候回使用写屏障，强制将cpu缓存中的变量刷新到主存中。这就是保证了可见性，同时也通过内存屏障防止指令重排，这就是有序性。
如何使用：
- 它修饰普通方法锁就是this，就是当前对象；
- 修饰静态方法，锁是类.class对象；
- 代码块，括号里面写什么它就锁什么；
什么是锁升级
要了解锁升级，就需要了解jdk1.6之前的synchronized的逻辑：
- 加锁本质上是调用操作系统底层原语mutex；
- 同时又涉及到线程的阻塞和唤醒；
- 但是Java线程是一对一的模型，每一个线程都直接对应一个操作系统的内核级线程，每次阻塞切换线程都需要操作系统从用户态切换到内核态，开销很大。
然而很多系统大多数时间并没有锁竞争，只在特定的时间并发量大，比如周末、618等。因此为了节约资源，低峰时期可以无锁，高峰时期为了应对锁竞争越来越激烈过程，从无锁升级到偏向锁、轻量级锁、重量级锁。
具体优化过程：
- 无锁：当只有一个线程来访问代码块时，JVM将对象头的Mark Word 锁标志位设置为偏向锁，然后将线程id记录到mark word里面，这个时候这个线程进入这个同步代码块就不需要其他同步操作了；
- 偏向锁：针对的是只有一个线程来抢锁的情况，当又第二个线程来抢锁的时候，就升级为轻量级锁；
- 轻量级锁：第二个抢锁的线程拿不到锁，就会采用cas加自旋的方式去获取锁。这种情况是属于锁不多占用时间也不长的情况，可以避免阻塞导致的用户态和内核态的切换产生的开销；
- 重量级锁：当第二个抢锁的线程自选到一定次数或者又更多的线程来抢锁，就会升级到重量级锁。此时对象头的Mark Word 的指针就会指向锁监视器monitor（负责记录锁的拥有者，锁的重入次数，负责线程的阻塞和唤醒）
⭐ThreadLocal
ThreadLocal有什么用？
**ThreadLocal 是 Java 中实现线程局部存储的工具：**每个线程都拥有自己独立的变量副本，线程之间互不干扰。简单说，同一个 ThreadLocal 变量在不同线程中存取的是不同的值。
ThreadLocal的原理了解吗？
- 存储方式：每一个线程里面有一个ThreadLocalMap，本质是一个hashmap，底层使用Entry数组来存储数据。其中entry的key是一个ThreadLocal的弱引用，value就是资源。
- key内存泄漏：在使用线程池的情况下，线程会一直被复用。这会导致ThreadLocal的强引用不在了，但是其他的引用链还是存在的，这也是为什么entry的key要设计为弱引用，这样gc回收的时候，key就能被垃圾回收，从而避免内存泄漏。
- key回收：只剩下entry的key的弱引用，没有其他强引用的时候，gc才能回收key。
- value清洗：当我们调用get或者set方法时候，就会遍历entry数组，清理掉key为null的entry。
- value强引用：如果value是弱引用的话，gc的时候没有强引用会导致被垃圾回收，导致处理业务过程中数据丢失。
- value内存泄漏：因此使用完之后，必须手动断开value的强引用（remove），然后让gc去回收掉。
- threadLocal和锁：都是为了解决并发安全；一个是访问同一个共享资源，另一个是复制资源各不干扰。
⭐线程池
为什么不推荐使用内置线程池？
队列的长度、线程的数量默认太大，可能会导致OOM
线程池常见的参数有那些？
| 参数名 | 类型 | 作用 |
|---|---|---|
corePoolSize |
int |
核心线程数 |
maximumPoolSize |
int |
最大线程数 |
keepAliveTime |
long |
非核心线程空闲存活时间 |
unit |
TimeUnit |
keepAliveTime 的时间单位 |
workQueue |
BlockingQueue<Runnable> |
任务阻塞队列 |
threadFactory |
ThreadFactory |
线程工厂（用于创建线程，可自定义名称、守护状态等） |
handler |
RejectedExecutionHandler |
拒绝策略（当队列满且线程数达到最大值时执行） |
拒绝策略有哪些？
| 策略类 | 行为 | 适用场景 |
|---|---|---|
AbortPolicy（默认） |
直接抛出 RejectedExecutionException 运行时异常 |
关键业务，不允许丢弃任务，需要上游感知并处理 |
CallerRunsPolicy |
由提交任务的线程（调用者）自己执行该任务 | 降低新任务提交速度，避免系统过载，适合对延迟不敏感、允许降级的场景 |
DiscardPolicy |
静默丢弃新提交的任务，不抛异常 | 非核心、可丢失的任务（如日志、埋点） |
DiscardOldestPolicy |
丢弃队列头部（最旧）的未处理任务，然后重新尝试提交当前任务 | 类似 DiscardPolicy，但优先保留新任务 |
⭐AQS
AQS是什么？AQS原理是什么？
AQS 是 AbstractQueuedSynchronizer 的缩写，是 Java 并发包（java.util.concurrent）中几乎所有锁和同步器的底层基础框架。ReentrantLock、CountDownLatch、Semaphore、ReentrantReadWriteLock 等都是基于 AQS 实现的。
原理：
- state：
- 其值为0，表示资源空闲；其值为1，表示资源被占有；这是ReentrantLock的思想。
- 可是就两个值为什么不设计为Boolean？那是因为在共享资源可以同时被n个线程访问的情况下，此时state的值为n，这就是semaphore的设计思想。
- 递归场景下，当前线程多次访问共享资源，访问一次state就要+1，释放一次就要-1，当state为0代表资源空闲。这是reentrantLock可重入的设计思想。
- 由于是多线程下，要保证可见性，所以该状态变量加上了volatile去保证可见性。
- 那原子性如何保证呢？这里使用的是cas去修改，来保证原子性。但是cas一直失败，就会阻塞放入队列FIFO中，等待被唤醒。
- tryAcquire：用于实现具体的获取共享资源的方式，AQS只需要知道有没有获取成功。
- acquire：会调用tryAcquire去获取资源，获取不到就阻塞。
- 公平性：FIFO队列为实现公平性提供了基础，实现类也可以自定义实现tryAcquire方法去自定义公平和非公平策略；
- ReentrantLock就是这么做的，它有一个FairSync和NonFairSync的子类，就是实现的tryAcquire方法。
- 共享和独占：
- 共享：多个线程共享资源，比如semaphore或者CountDonwLatch；
- 独占：只允许一个线程独占资源，对应AQS的acquire和tryAcquire，在reentrantlock里的表现就是lock和trylock。
- condition：用于管理调用了await的线程，将其放入条件队列中；
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来源 coder-xuyong！
相关推荐
2025-10-16
Java并发核心机制
Java 并发核心机制 Java 对于并发的支持主要汇聚在 java.util.concurrent，即 J.U.C。而 J.U.C 的核心是 AQS。 J.U.C 简介Java 的 java.util.concurrent 包（简称 J.U.C）中提供了大量并发工具类，是 Java 并发能力的主要体现（注意，不是全部，有部分并发能力的支持在其他包中）。从功能上，大致可以分为： 原子类 - 如：AtomicInteger、AtomicIntegerArray、AtomicReference、AtomicStampedReference 等。 锁 - 如：ReentrantLock、ReentrantReadWriteLock 等。 并发容器 - 如：ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet 等。 阻塞队列 - 如：ArrayBlockingQueue、LinkedBlockingQueue 等。 非阻塞队列 - 如： ConcurrentLinkedQueue 、LinkedTransferQueue...
2025-10-15
Java并发简介
并发概念进程和线程 进程： 可以视为程序的一个实例。 线程： 线程作为最小调度单位，进程作为资源分配的最小单位。 一个进程之内可以分为一到多个线程。 一个线是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行 Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。 在 windows 中进程是不活动的，只是作为线程的容器。 进程和线程的差异： 一个程序至少有一个进程，一个进程至少有一个线程。 线程比进程划分更细，所以执行开销更小，并发性更高 进程是一个实体，拥有独立的资源；而同一个进程中的资源是多个线程共享的。 并行与并发单核 cpu 下，线程实际还是串行执行的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的 。总结为一句话就是： 微观串行，宏观并行 ，一般会将这种 线程轮流使用 CPU 的做法称为并发， concurrent cpu 时间片1 时间片2 时间片3 时间片4 co...
2025-10-17
Java锁
深入理解 Java 并发锁 本文先阐述 Java 中各种锁的概念。 然后，介绍锁的核心实现 AQS。 然后，重点介绍 Lock 和 Condition 两个接口及其实现。并发编程有两个核心问题：同步和互斥。 互斥，即同一时刻只允许一个线程访问共享资源； 同步，即线程之间如何通信、协作。 这两大问题，管程（sychronized）都是能够解决的。J.U.C 包还提供了 Lock 和 Condition 两个接口来实现管程，其中 Lock 用于解决互斥问题，Condition 用于解决同步问题。 并发锁简介确保线程安全最常见的做法是利用锁机制（Lock、sychronized）来对共享数据做互斥同步，这样在同一个时刻，只有一个线程可以执行某个方法或者某个代码块，那么操作必然是原子性的，线程安全的。 可重入锁可重入锁，顾名思义，指的是线程可以重复获取同一把锁。即同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。 如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住。 可重入锁可以在一定程度上避免死锁。 ReentrantLock 、ReentrantReadWrite...
2025-10-17
Java并发工具类
Java 并发工具类 JDK 的 java.util.concurrent 包（即 J.U.C）中提供了几个非常有用的并发工具类。 CountDownLatch 字面意思为 递减计数锁。用于控制一个线程等待多个线程。 CountDownLatch 维护一个计数器 count，表示需要等待的事件数量。countDown 方法递减计数器，表示有一个事件已经发生。调用 await 方法的线程会一直阻塞直到计数器为零，或者等待中的线程中断，或者等待超时。 CountDownLatch 是基于 AQS(AbstractQueuedSynchronizer) 实现的。 CountDownLatch 唯一的构造方法： 12// 初始化计数器public CountDownLatch(int count) {}; 说明： count 为统计值。 CountDownLatch 的重要方法： 123public void await() throws InterruptedException { };public boolean await(long...
2025-10-17
Java并发和容器
Java 并发和容器同步容器同步容器简介在 Java 中，同步容器主要包括 2 类： Vector、Stack、Hashtable Vector - Vector 实现了 List 接口。Vector 实际上就是一个数组，和 ArrayList 类似。但是 Vector 中的方法都是 synchronized 方法，即进行了同步措施。 Stack - Stack 也是一个同步容器，它的方法也用 synchronized 进行了同步，它实际上是继承于 Vector 类。 Hashtable- Hashtable 实现了 Map 接口，它和 HashMap 很相似，但是 Hashtable 进行了同步处理，而 HashMap 没有。 Collections 类中提供的静态工厂方法创建的类（由 Collections.synchronizedXXX 等方法） 同步容器的问题同步容器的同步原理就是在其 get、set、size 等主要方法上用 synchronized 修饰。 性能问题synchronized 的互斥同步会产生阻塞和唤醒线程的开销。显然，这种方式比没有使用 syn...
2025-10-18
Java内存模型
Java 内存模型 关键词：JMM、volatile、synchronized、final、Happens-Before、内存屏障 Java 内存模型（Java Memory Model），简称 JMM。Java 内存模型的目标是为了解决由可见性和有序性导致的并发安全问题。Java 内存模型通过 屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。 物理内存模型物理机遇到的并发问题与虚拟机中的情况有不少相似之处，物理机对并发的处理方案对于虚拟机的实现也有相当大的参考意义。 硬件处理效率物理内存的第一个问题是：硬件处理效率。 绝大多数的运算任务都不可能只靠处理器“计算”就能完成，处理器至少需要与内存交互，如读取运算数据、存储运算结果，这个 I/O 操作是很难消除的（无法仅靠寄存器完成所有运算任务）。 由于计算机的存储设备与处理器的运算速度有几个数量级的差距 ，这种速度上的矛盾，会降低硬件的处理效率。所以，现代计算机都不得不 加入高速缓存（Cache） 来作为内存和处理器之间的缓冲。将需要用到的数据复制到缓存中，让运算能...
评论
