Synchronized 关键字详解

桃扇骨 2024-02-19 21:59 48阅读 0赞

**目录**

1、Synchronized 关键字简单介绍

（1）Synchronized 的使用示例

（2）什么是可重入锁？

2、Synchronized 的实现原理

Java中的监视器锁（Monitor Lock）机制

3、Synchronized 的锁优化过程详解

（1）Java 锁的膨胀过程详解

（2）偏向锁的实现原理解析

（3）操作系统的互斥量（mutex）的实现原理（重量级锁）

--------------------

### 1、Synchronized 关键字简单介绍 ###

synchronized 是 Java 中的一种同步机制，用于实现线程之间的互斥和同步。当一个线程需要访问一个对象的同步代码块时，如果这个同步代码块已经被另一个线程所占用，那么当前线程就会被阻塞，直到另一个线程执行完毕并释放锁。只有获取到锁的线程才能执行同步代码块。

synchronized 可以用于两种方式：

1.  **修饰方法：**使用 `synchronized` 关键字修饰一个方法时，该方法被称为同步方法。当一个线程访问一个对象的同步方法时，其他线程将被阻塞，直到该线程执行完毕并释放锁。同步方法的锁对象是当前实例对象。
2.  **修饰代码块：**使用 `synchronized` 关键字修饰一段代码时，称该代码块为同步代码块。同步代码块必须指定某个对象作为锁，当一个线程访问同步代码块时，必须先获得锁，其他线程将被阻塞，直到该线程执行完毕并释放锁。

在使用 `synchronized` 时，需要注意以下几点：

1.  `synchronized` 是一种重量级的操作，会影响性能。在使用 `synchronized` 时，应尽可能减小同步块的范围，避免锁的竞争。
2.  `synchronized` 锁的范围应该尽量小，只保护必要的代码块，避免对整个方法或对象进行锁定。
3.  `synchronized` 锁定的对象不应该被修改，否则会导致死锁的发生。
4.  在使用 `synchronized` 时，需要考虑线程间的协调和通信，以避免死锁和活锁的发生。

**Synchronized 锁的类型：**

synchronized 是**悲观锁**的实现，因为 synchronized 修饰的代码，每次执行时都会进行加锁操作，同时只允许一个线程进行操作，所以它是悲观锁的实现。

synchronized 是**非公平锁**，并且是不可设置的。这是因为非公平锁的吞吐量大于公平锁，并且是主流操作系统线程调度的基本选择，所以这也是 synchronized 使用非公平锁原因。

同时，synchronized是一个典型的**可重入锁**，可重入锁最大的作用是避免死锁。

#### （1）Synchronized 的使用示例 ####

Synchronized 可以用来保证代码块或方法的同步执行，下面是一些 Synchronized 的使用示例：

（1）保证方法的同步执行

public synchronized void synchronizedMethod() {
        // 这里是需要同步的代码
    }

（2）保证代码块的同步执行

public void someMethod() {
        synchronized(this) {
            // 这里是需要同步的代码
        }
    }

使用 synchronized 可以保证同步代码块在同一时刻只能被一个线程执行，从而保证了线程安全。

#### （2）什么是可重入锁？ ####

可重入锁是一种特殊的互斥锁，也被称为递归锁。在一个线程已经持有某个锁的情况下，同一个线程再次请求该锁时，请求会成功，不会造成死锁。可重入锁的意义在于，避免线程因为无法获得自己已经持有的锁而进入死锁状态。

在Java 中，synchronized 和 ReentrantLock 都是可重入锁。其中 synchronized 是 JVM 内置的锁，而 ReentrantLock 是 JDK 提供的一个可重入的互斥锁。在使用可重入锁时，同一个线程多次获取同一个锁时，不会造成死锁或者无限等待的情况，因为锁已经被当前线程占用，因此该线程可以直接进入临界区。// 一般Java中的锁都是可重入锁，不可重入锁会带来很多死锁问题

### 2、Synchronized 的实现原理 ###

Synchronized 的实现原理基于Java中的监视器锁（Monitor Lock），每个Java对象都与一个监视器相关联，监视器是一个同步队列，用于实现线程同步。

当一个线程想要访问一个被Synchronized保护的代码块时，它必须首先获得这个对象的监视器。如果这个监视器已经被其他线程获得了，那么这个线程就会被阻塞，直到该监视器被释放。如果该监视器未被其他线程占用，则获得该监视器并进入同步块。当线程执行完同步块中的代码时，它会释放监视器，这样其他线程就可以继续访问共享资源了。

Java中的每个对象都有一个锁（Lock）和一个等待集（wait set）。当线程试图进入同步代码块时，它必须先获得对象的锁。如果锁已经被其他线程持有，则该线程将被阻塞，直到锁被释放。同时，该线程会将自己加入对象的等待集中。当锁被释放时，等待集中的线程就会被唤醒，试图重新获取锁。这种等待集的机制是基于操作系统的信号量（semaphore）实现的，Java中的监视器机制使用了类似的机制。

所以，Synchronized是通过Java对象的监视器和等待集实现了线程的同步和互斥，保证了线程安全的同时也降低了锁的开销。

// 每个Object对象中都内置了一个monitor对象，monitor对象存在于每个Java对象的对象头中(存储的是指针)。monitor相当于一个许可证，线程拿到许可证即可以进行操作，没有拿到则需要阻塞等待。

#### Java中的监视器锁（Monitor Lock）机制 ####

Java 中的监视器锁（Monitor Lock）是一种基于内置锁（Intrinsic Lock）实现的同步机制，它通过线程获取对象的内置锁来实现线程的同步访问。

每个 Java 对象都与一个监视器相关联，监视器包含一个计数器和一个线程等待队列，计数器记录持有该对象锁的线程数量。当一个线程请求获得对象的锁时，如果对象的计数器为0，则该线程可以立即获取该对象的锁并将计数器加1，如果对象的计数器不为0，则该线程将进入该对象的线程等待队列并等待被唤醒。当一个线程释放对象的锁时，它将减少计数器并从等待队列中唤醒一个等待线程，让其获取该对象的锁。// 这个机制很重要，基于一个计数器，一个等待队列

监视器锁（Monitor Lock）的优点是简单易用，只需要使用 `synchronized` 关键字即可实现对共享资源的访问控制。缺点是只能实现互斥访问，不能进行读写分离，也无法实现公平性控制，容易导致线程饥饿问题。

### 3、Synchronized 的锁优化过程详解 ###

Synchronized 在实现过程中，有一种锁优化机制——**锁的粗化（Lock Coarsening）、锁的消除（Lock Elimination）、锁的膨胀（Lock Inflation）**。//JDK 6 以后的版本中对 Synchronized 进行了锁优化

锁的粗化指的是，当连续的加锁和解锁操作在同一个代码块中出现时，虚拟机会将其合并成一个范围更大的锁，从而避免频繁加锁和解锁所带来的性能消耗。

锁的消除指的是，当虚拟机检测到一些对象不存在竞争，也就是说，该对象只被一个线程访问，那么它就会自动消除对这些对象的加锁操作，从而减少不必要的锁操作。// 偏向锁

锁的膨胀指的是，当虚拟机检测到一个线程在短时间内多次加锁和解锁同一个对象时，就会将这个锁升级成重量级锁，以避免频繁的用户态和内核态切换所带来的性能开销。

通过锁的粗化、锁的消除和锁的膨胀，Synchronized 锁的效率得到了很大的提升，可以更好地支持多线程应用程序的并发处理。

#### （1）Java 锁的膨胀过程详解 ####

Java中的锁通常有四个状态：**无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态**。这些状态是在不同的竞争条件下产生的，并且代表着不同的锁竞争强度。

当一个线程访问一个没有被锁住的synchronized块时，它会在对象头中记录一个指向它的线程ID。这个线程在之后的访问中可以直接获取锁，这被称为**偏向锁**。

偏向锁可以大大减少竞争，因为它不需要任何同步来获取锁。这对于对象的成员方法的同步非常有用，因为它们通常由单个线程访问，例如在单线程情况下运行的Swing事件分派线程。

当两个或更多个线程竞争访问同一个synchronized块时，它们将尝试通过**轻量级锁**来获取锁。当线程获取锁时，它将锁拷贝到它自己的锁记录中，并使用CAS操作将锁存储到对象头中。如果锁被占用，则线程尝试自旋获取锁。如果锁占用的时间很短，自旋获取锁的时间会很短，因此这种方式比使用重量级锁更高效。

如果线程无法获得锁，则轻量级锁会膨胀为**重量级锁**。重量级锁涉及到内核级别的线程同步，因此它的性能相对较低。当线程释放锁时，锁状态将恢复为无锁状态。

锁的状态转换通常是自动的，不需要手动干预。然而，如果需要进行手动干预，可以使用JVM参数来控制锁的状态转换。例如，可以通过-XX:BiasedLockingStartupDelay参数来控制偏向锁的延迟启动时间，从而改变默认设置。

#### （2）偏向锁的实现原理解析 ####

偏向锁是 Java 中一种针对轻量级同步场景的锁优化技术。它的基本思想是，如果一个线程获得了一个对象的锁，那么在之后的一段时间内，这个线程再次请求这个锁时，可以直接获得锁，无需竞争。

当一个对象被创建时，默认情况下它不是偏向锁，也就是说没有被任何线程所占有。当一个线程第一次进入同步块时，会尝试获取锁并把对象头中的 Mark Word 设置为偏向锁。同时，这个线程会把这个对象头中的 Thread ID 信息记录下来，表示这个线程已经持有了这个对象的锁。// 偏向锁的实现原理，无同步竞争，减少锁的开支

之后，当这个线程再次进入同步块时，无需进行加锁操作，而只需检查对象头中的 Thread ID 信息是否为当前线程即可。如果是，表示这个线程已经持有了这个对象的锁，直接执行同步块即可。这样的好处是避免了竞争，减少了线程上下文切换的次数，从而提升了程序的执行效率。

需要注意的是，当其他线程尝试获得偏向锁的对象的锁时，偏向锁会自动撤销，变为轻量级锁或重量级锁，其他线程再次进入同步块时，需要进行加锁操作，也就是说这个对象的锁被多个线程竞争。这种情况下，偏向锁的优化就失效了。

**对象头中的 Mark Word：**

在 Java 虚拟机中，每个对象都有一个对象头，用于存储对象的元信息，如对象的哈希码、锁状态、GC 信息等。其中，Mark Word 是对象头中的一部分，用于存储对象的锁状态和一些其他的标记信息。

Mark Word 的内容根据对象的状态不同而有所不同，以下是一些常见情况下 Mark Word 的内容：

1.  **无锁状态：**对象尚未被任何线程加锁。此时 Mark Word 中的状态位为 01，同时存储了对象的哈希码和分代年龄等信息。
2.  **偏向锁状态：**对象曾经被一个线程加过偏向锁，并且该线程仍然持有锁。此时 Mark Word 中的状态位为 01，存储了锁的持有者线程 ID、偏向锁标识位、对象分代年龄和哈希码等信息。
3.  **轻量级锁状态：**对象正在被多个线程竞争锁。此时 Mark Word 中的状态位为 00，存储了指向锁记录的指针。
4.  **重量级锁状态：**对象被一个线程持有，并且有多个线程正在竞争锁。此时 Mark Word 中的状态位为 10，存储了指向重量级锁的指针。

需要注意的是，不同的 JVM 实现可能有不同的 Mark Word 结构和标志位含义，上述仅是一些常见情况下的示例。

#### （3）操作系统的互斥量（mutex）的实现原理（重量级锁） ####

操作系统中的互斥量（mutex）是一种用于保护临界区的同步机制，用于确保同时只有一个线程访问临界资源，从而避免并发问题。互斥量的实现原理可以分为用户态和内核态两种方式。

在用户态下，互斥量通常是通过原子操作和忙等待实现的。原子操作是指不可中断的操作，比如 Test-and-Set 操作，可以保证多个线程并发访问时不会出现竞争问题。忙等待是指线程在访问共享资源时，一直循环检查是否可以进入临界区，这种方式效率比较高，但是会占用 CPU 资源，造成浪费。// 用户状态下，线程不用进行等待，效率比较高

在内核态下，互斥量的实现是基于操作系统提供的原语，通常是通过系统调用实现的。当线程需要获取互斥量时，会调用系统调用将自己挂起，等待互斥量可用。当互斥量可用时，操作系统会将线程唤醒，使其可以进入临界区。这种方式避免了忙等待，但是由于涉及到内核态和用户态之间的切换，因此效率相对较低。// 内核模式下，线程被挂起

在实际使用中，需要根据具体情况选择合适的实现方式。如果临界区较小，线程数较少，可以使用用户态的互斥量实现；如果临界区较大，线程数较多，应该使用内核态的互斥量实现。在Java中，重量级锁的实现依赖于操作系统提供的同步原语。通常情况下，Java的重量级锁会对应到操作系统的互斥量（mutex）。因此，重量级锁的实现和操作系统的互斥量实现原理相似。