大厂面试题详解：synchronized的偏向锁和自旋锁怎么实现的
理解 synchronized 关键字
在 Java 中，synchronized 关键字是实现并发控制的重要工具之一。它用于实现对共享资源的互斥访问，确保在同一时刻只有一个线程可以进入同步代码块或方法。
synchronized 的基本用法
public class SynchronizedExample { private int count = 0; public synchronized void increment() { count++; } }
在上述示例中，increment() 方法被 synchronized 修饰，保证了对 count 的操作是原子的，即线程安全的。
synchronized 的性能问题
传统的 synchronized 在竞争激烈的情况下可能会导致性能问题，因为它会涉及到线程的上下文切换和用户态与内核态的切换。
偏向锁的引入
为了解决 synchronized 在单线程情况下的性能问题，JDK 1.6 引入了偏向锁的概念。偏向锁是一种针对单线程场景进行优化的锁机制，它可以减少无竞争情况下的同步操作开销。
偏向锁的实现原理
public class SynchronizedExample { private int count = 0; public synchronized void increment() { count++; } }
在单线程访问的情况下，synchronized 会尝试偏向于这个线程。当有其他线程尝试访问这个锁时，偏向锁就会升级为常规锁，保证多线程下的正确性。
自旋锁的引入
自旋锁是一种基于循环等待的锁，线程在获取锁时不会被挂起，而是不断地尝试获取锁。
自旋锁的实现原理
import java.util.concurrent.atomic.AtomicBoolean; public class SpinLockExample { private AtomicBoolean locked = new AtomicBoolean(false); public void lock() { while (!locked.compareAndSet(false, true)) { // 自旋等待锁释放 } } public void unlock() { locked.set(false); } }
在自旋等待期间，线程会一直占用 CPU 资源，如果等待时间过长，会导致性能问题。因此，自旋锁适用于短时间内持有锁的情况。
应用场景和最佳实践
synchronized 的适用场景
- 单线程访问或轻量级的并发情况下，可以使用 synchronized，它简单易用，且性能较好。
- 对于竞争激烈的场景或高并发环境，考虑使用 ReentrantLock 或者 ConcurrentHashMap 等并发工具类。
偏向锁和自旋锁的应用场景
- 偏向锁适用于单线程访问的场景，可以提升同步操作的性能。
- 自旋锁适用于短时间内持有锁的情况，可以减少线程上下文切换的开销。
高级应用和性能优化
偏向锁的优化
偏向锁在单线程场景下提供了很好的性能优化，但在多线程竞争激烈的情况下，偏向锁的性能会下降。为了解决这个问题，JVM 会根据一定的规则自动取消偏向锁。
偏向锁的实现机制涉及到锁标识位的设置与撤销，其主要流程包括偏向锁的获取、撤销和升级。
示例代码：
public class BiasedLockExample { private int value = 0; public synchronized void increment() { value++; } }
上述代码中的 increment() 方法使用了 synchronized 关键字，这意味着该方法是一个同步方法，会使用偏向锁进行优化。
自旋锁的优化
自旋锁的性能受到 CPU 核心数和线程竞争情况的影响。当线程竞争不激烈或锁持有时间较短时，自旋锁可以提升性能。但如果自旋等待时间过长，会造成资源浪费。
自旋锁通过循环重试的方式尝试获取锁，避免了线程阻塞和切换的开销。
示例代码：
import java.util.concurrent.atomic.AtomicBoolean; public class SpinLock { private AtomicBoolean locked = new AtomicBoolean(false); public void lock() { while (!locked.compareAndSet(false, true)) { // 自旋等待锁释放 } } public void unlock() { locked.set(false); } }
上述代码中，lock() 方法通过 AtomicBoolean 类型的状态标识来实现自旋锁的获取，unlock() 方法用于释放锁。
使用 synchronized 关键字
尽管 ReentrantLock 提供了更多的灵活性和功能，但在绝大多数情况下，synchronized 关键字已经能够满足需求，并且使用更为简单和方便。
synchronized 关键字的使用简单直接，JVM 对其进行了高度优化，性能较为优秀。在绝大多数情况下，synchronized 能够满足锁的需求，并且使用更为简单和方便。
示例代码：
public class SynchronizedExample { private int count = 0; public synchronized void increment() { count++; } }
上述代码中的 increment() 方法使用了 synchronized 关键字，保证了方法的原子性，避免了多线程并发访问导致的数据不一致问题。
应用场景
偏向锁的应用场景： 偏向锁适用于存在大量读线程的场景，通过偏向锁可以减少无谓的竞争，提高性能。
假设有一个数据结构，被多个线程读取，但只有少数线程会修改数据。在这种场景下，偏向锁可以提供显著的性能优势，因为大多数情况下读线程无需争夺锁，可以直接访问数据，而修改数据的线程会在获得锁后进行修改。
/** * 偏向锁的应用场景： * 偏向锁适用于存在大量读线程的场景，通过偏向锁可以减少无谓的竞争，提高性能。 * * 假设有一个数据结构，被多个线程读取，但只有少数线程会修改数据。在这种场景下，偏向锁可以提供显著的性能优势， * 因为大多数情况下读线程无需争夺锁，可以直接访问数据，而修改数据的线程会在获得锁后进行修改。 */ public class BiasedLockExample { // 定义共享的数据 private int data = 0; /** * 读取数据的方法 */ public synchronized void readData() { System.out.println("Reading data: " + data); } /** * 修改数据的方法 * @param newData 新数据 */ public synchronized void modifyData(int newData) { // 修改数据 data = newData; System.out.println("Data modified to: " + data); } }
在上述代码中，我展示了一个简单的应用场景，适合使用偏向锁进行性能优化。在这个示例中，多个线程可以同时调用 readData() 方法读取数据，而只有在调用 modifyData(int newData) 方法时才需要竞争偏向锁进行数据修改。
通过使用偏向锁，大多数情况下读取数据的线程无需竞争锁资源，可以直接访问数据，而修改数据的线程则会在获得锁之后进行数据修改操作，有效减少了竞争和锁的开销，提高了系统的性能和吞吐量。
自旋锁的应用场景： 自旋锁适用于锁的持有时间短、线程并发数不高的场景，可以有效减少线程阻塞和切换带来的开销。
自旋锁适用于并发竞争不激烈、锁竞争时间较短的场景，例如某个资源被多个线程轮流访问的情况，可以有效减少线程切换的开销。
/** * 自旋锁的实现： * 自旋锁是一种基于循环等待的锁，线程在获取锁时不会被挂起，而是不断地尝试获取锁。 * * 自旋锁适用于锁的持有时间较短、线程竞争不激烈的情况下，可以有效减少线程阻塞和切换带来的开销。 */ import java.util.concurrent.atomic.AtomicBoolean; public class SpinLock { // 使用AtomicBoolean作为状态标志，初始化为false表示未锁定状态 private AtomicBoolean locked = new AtomicBoolean(false); /** * 加锁方法，使用自旋等待获取锁 */ public void lock() { // 使用CAS操作尝试获取锁，直到成功为止 while (!locked.compareAndSet(false, true)) { // 自旋等待锁释放 // 在自旋过程中，当前线程不会被挂起，而是一直循环尝试获取锁 } } /** * 解锁方法，将锁标志位设置为false */ public void unlock() { // 将锁标志位设置为false，表示释放锁 locked.set(false); } }
在上述代码中，我实现了一个简单的自旋锁，采用了基于CAS（Compare And Set）操作的方式来实现加锁和解锁的过程。在 lock() 方法中，线程会不断地循环尝试获取锁，直到成功获取为止。而在 unlock() 方法中，线程会将锁的状态标志位设置为false，表示释放锁。
自旋锁适用于锁的持有时间较短、线程竞争不激烈的情况下，可以有效减少线程阻塞和切换带来的开销，提高系统的性能和吞吐量。
synchronized 关键字的应用场景： synchronized 关键字适用于绝大多数的同步场景，尤其是对于简单的同步操作，synchronized 提供了更为简单和便捷的使用方式。
synchronized 关键字是 Java 中最常用的同步机制，它可以用于任何对象和方法，提供了一种简单而强大的同步方式。
示例代码：
/** * synchronized 关键字的应用场景： * synchronized 关键字适用于绝大多数的同步场景，尤其是对于简单的同步操作，synchronized 提供了更为简单和便捷的使用方式。 * synchronized 关键字是 Java 中最常用的同步机制，它可以用于任何对象和方法，提供了一种简单而强大的同步方式。 */ public class SynchronizedCounter { // 定义一个计数器变量 private int count = 0; /** * synchronized 关键字修饰的方法，用于增加计数器的值 */ public synchronized void increment() { // 在方法内部使用 synchronized 关键字，确保了对 count 变量的操作是原子的，即线程安全的 count++; } /** * synchronized 关键字修饰的方法，用于获取计数器的值 */ public synchronized int getCount() { // 在方法内部使用 synchronized 关键字，确保了对 count 变量的读取操作是线程安全的 return count; } }
在上述代码中，我定义了一个简单的计数器类 SynchronizedCounter，其中的 increment() 和 getCount() 方法都使用了 synchronized 关键字修饰，这样可以确保对计数器变量 count 的操作是线程安全的。无论是增加计数器的值还是获取计数器的值，都能保证在多线程环境下的正确性和一致性。
synchronized 关键字适用于大多数的同步场景，特别是对于简单的同步操作，它提供了一种简单而强大的同步方式。因此，在绝大多数情况下，我可以使用 synchronized 关键字来确保线程安全，而无需引入更复杂的同步机制。
