AI带我学Java-多线程(三): synchronized

AI改变世界吗
99 阅读12分钟

在Java并发编程中,synchronized关键字是最基本也是最常用的同步机制。它提供了一种简单的方式来保证代码块或方法在同一时刻只能被一个线程执行,从而避免了多个线程同时访问共享资源导致的数据不一致问题。本文将深入探讨synchronized的原理、使用方法、性能优化以及最佳实践,帮助你全面掌握这一重要的Java同步机制。

1. synchronized的基本概念和使用方法

synchronized关键字可以用于修饰方法或代码块。当一个线程尝试执行一个synchronized方法或进入一个synchronized代码块时,它必须首先获取相应的锁。如果该锁已经被其他线程占有,那么这个线程将被阻塞,直到它获取到锁为止。

1.1 synchronized方法

当synchronized用于修饰一个方法时,它会锁定当前对象(即this),防止其他线程同时执行该对象的其他synchronized方法:

public synchronized void method() {
    // ...
}

对于静态方法,synchronized会锁定该方法所属的类对象:

public static synchronized void staticMethod() {
    // ...
}

1.2 synchronized代码块

当synchronized用于修饰一个代码块时,它会锁定指定的对象,防止其他线程同时执行该对象的synchronized代码块或synchronized方法:

synchronized (obj) {
    // ...
}

这里的obj可以是this,也可以是其他任意对象。不同的对象锁之间是互不影响的,即获取了对象A的锁并不会阻止其他线程获取对象B的锁。

2. synchronized的底层实现原理

要深入理解synchronized,我们需要了解它的底层实现原理,特别是Java对象头(Object Header)、Monitor以及锁升级的概念。

2.1 Java对象头和Monitor

在JVM中,每个Java对象都有一个对象头(Object Header),其中包含了对象的HashCode、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等信息。对象头中与synchronized相关的是锁状态标志和Monitor。

Monitor是JVM中用于实现synchronized的一种机制。每个Java对象都关联了一个Monitor。Monitor中包含了一个计数器、一个等待队列和一个拥有者线程的引用。当一个线程尝试获取一个对象的锁时,JVM会检查该对象的Monitor的计数器是否为0。如果是,JVM会将该线程设置为Monitor的拥有者,并将计数器加1。如果不是,该线程会被放入Monitor的等待队列,直到拥有者线程释放锁。

2.2 synchronized的锁升级

image.png 为了提高synchronized的性能,JVM引入了锁升级的机制。锁升级是指JVM在运行时根据synchronized的使用情况,自动将锁从低级别升级到高级别,以减少锁的开销。JVM中有三种锁模式:偏向锁、轻量级锁和重量级锁。

  • 偏向锁:当一个线程反复进入同一个synchronized代码块时,JVM会使用偏向锁。偏向锁会将对象头中的线程ID设置为当前线程ID,这样当前线程再次进入该synchronized代码块时,无需再进行锁定操作。如果其他线程尝试获取该锁,JVM会撤销偏向锁,并升级为轻量级锁。
  • 轻量级锁:在不同的线程交替执行同一个synchronized代码块的情况下,JVM会使用轻量级锁。轻量级锁的本质是自旋锁。当一个线程尝试获取一个对象的锁时,如果该对象的Mark Word中的锁标志位为0,那么该线程会将Mark Word复制到其栈帧中的Lock Record中,然后用CAS操作将Mark Word中的锁标志位设为00(表示轻量级锁)。如果CAS操作成功,那么该线程就获取了该对象的轻量级锁。如果CAS操作失败,那么该线程会自旋一段时间,如果在自旋期间其他线程释放了该锁,那么该线程就可以重新尝试获取该锁。
  • 重量级锁:在不同的线程竞争同一个锁的情况下,JVM会使用重量级锁。当一个线程尝试获取一个对象的锁时,如果该对象的Mark Word中的锁标志位为10(表示重量级锁),或者自旋一定次数后仍未获取到轻量级锁,那么该线程就会进入到Monitor的等待队列中,等待拥有该锁的线程释放该锁。这种情况下,线程的阻塞和唤醒都需要操作系统的介入,因此开销较大。

JVM会根据运行时的状况,自动在这些锁模式之间进行切换。例如,如果一个对象最初被一个线程反复访问,那么它会使用偏向锁。如果后来另一个线程也开始访问这个对象,那么偏向锁就会升级为轻量级锁。如果多个线程竞争同一个锁,那么轻量级锁就会升级为重量级锁。这种锁升级的过程是自动进行的,无需程序员干预。

2.3 撤销偏向锁的实现细节

当一个线程尝试获取一个偏向另一个线程的锁时,JVM需要撤销偏向锁,这个过程会暂停所有线程(Stop The World)。具体的步骤如下:

  1. JVM在该线程的栈中创建一个空间,称为Lock Record,用于存储锁对象的Mark Word。
  2. JVM将锁对象的Mark Word复制到Lock Record中。
  3. JVM使用CAS操作将锁对象的Mark Word更新为指向Lock Record的指针,同时将锁状态标志位更新为00(表示轻量级锁)。
  4. 如果CAS操作成功,那么该线程就获取了该锁,并且该锁从偏向锁升级为轻量级锁。
  5. 如果CAS操作失败,说明有其他线程同时在尝试获取该锁,那么JVM会循环执行步骤2-4,直到成功为止。

在这个过程中,所有的线程都会被暂停(Stop The World),因为JVM需要扫描所有其他线程持有该锁的引用,并将这些引用更新为指向Lock Record。这个过程需要停止所有的线程,以避免在扫描和更新的过程中有新的引用产生。

这个过程的时间复杂度与线程数和锁对象的引用数成正比。因此,如果一个锁对象被大量线程频繁地争用,那么撤销偏向锁的过程就会变得非常耗时,甚至可能成为系统的性能瓶颈。这就是为什么在高并发场景下,我们通常会使用-XX:-UseBiasedLocking参数来禁用偏向锁。

2.4 原子性、可见性和有序性的实现

synchronized不仅提供了代码块或方法的原子性,还保证了共享变量的可见性和同步代码块的有序性。这是通过JVM和操作系统的配合实现的。

在保证原子性方面,JVM通过对Monitor的操作来实现。当一个线程获取一个对象的锁时,JVM会将该线程设置为Monitor的拥有者,并将Monitor的计数器加1。这个过程是原子的,由JVM保证。在操作系统层面,JVM通常使用操作系统提供的互斥量(Mutex)或信号量(Semaphore)机制来实现Monitor。互斥量保证了在同一时刻只有一个线程能够进入临界区(Critical Section),即同步代码块。

在保证可见性方面,JVM通过对象头的锁信息和内存屏障(Memory Barrier)机制实现。当一个线程获取一个对象的锁时,JVM会将该线程的ID写入对象头。当该线程修改共享变量时,JVM会将修改后的值立即写回主内存。当其他线程获取同一个对象的锁时,JVM会从主内存中读取共享变量的最新值。在操作系统层面,JVM使用内存屏障指令来保证共享变量的修改对其他线程是可见的。内存屏障是一种CPU指令,它保证了在该指令之前的所有写操作都已经写回主内存,并且在该指令之后的所有读操作都能读到最新的值。

在保证有序性方面,JVM通过在同步代码块的开始和结束位置插入内存屏障来实现。这些内存屏障防止了同步代码块内部的指令重排序。在操作系统层面,一些CPU架构提供了特殊的指令(如x86的lock前缀,ARM的dmb指令)来生成内存屏障,防止指令重排序。

3. synchronized的性能优化

尽管synchronized提供了一种简单可靠的同步机制,但它也有一些性能上的缺陷。例如,当多个线程竞争同一个锁时,会导致线程的上下文切换和CPU时间的浪费。此外,synchronized是一种阻塞式的同步机制,当一个线程获取不到锁时,它会一直阻塞,直到获取到锁为止。这可能会导致系统的响应性下降。

为了提高synchronized的性能,我们可以采取以下几种优化措施:

  1. 减小锁的粒度:尽量将synchronized的范围缩小到最小,只对必要的代码块或方法进行同步。这样可以减少线程的阻塞时间和锁的竞争。
  2. 避免对象的共享:如果一个对象不需要在多个线程之间共享,那么就不要使用synchronized来同步对它的访问。而是应该将它作为线程的私有变量来使用。
  3. 使用锁分离:如果一个类中有多个synchronized方法,但它们之间没有依赖关系,那么可以考虑将它们的锁分离开来。例如,可以为每个方法创建一个单独的锁对象,而不是使用this作为锁对象。这样可以减少锁的竞争。
  4. 使用锁粗化:如果一个线程反复地进入和退出同一个synchronized代码块,那么可以考虑将这些代码块合并为一个更大的synchronized代码块。这样可以减少锁的获取和释放的次数,从而提高性能。
  5. 使用锁消除:如果JVM检测到一个synchronized代码块中的代码没有对共享变量进行修改,那么它可以将该代码块去除同步操作。这种优化称为锁消除。

4. synchronized的最佳实践

虽然synchronized有一些性能上的缺陷,但它仍然是Java中最基本和最常用的同步机制。在使用synchronized时,我们应该遵循以下几个最佳实践:

  1. 只对需要同步的代码进行同步:过度同步会导致性能问题,因此我们应该仔细分析哪些代码需要同步,哪些代码不需要同步。
  2. 尽量使用synchronized代码块,而不是synchronized方法:synchronized代码块的粒度更细,可以减少线程的阻塞时间。
  3. 避免在synchronized代码块中调用可能会阻塞的方法:如果在synchronized代码块中调用了一个可能会阻塞的方法(如I/O操作),那么可能会导致所有试图获取该锁的线程都被阻塞。
  4. 考虑使用其他的同步机制:在某些场景下,使用Lock、ReadWriteLock、Atomic等其他同步机制可能会比synchronized更高效。
  5. 避免死锁:死锁是指两个或多个线程互相等待对方释放锁,从而导致所有线程都被阻塞。为了避免死锁,我们应该按照一定的顺序来获取锁,并且在必要时使用定时锁(如Lock.tryLock(long,TimeUnit))。

5. 总结

synchronized是Java中最基本和最常用的同步机制。它通过对象头中的锁信息和Monitor机制来实现对代码块或方法的同步访问。synchronized不仅提供了原子性,还保证了可见性和有序性。

为了提高synchronized的性能,JVM引入了偏向锁、轻量级锁和重量级锁等不同的锁模式,并且可以在运行时自动进行锁升级。但是,锁升级也有其开销,特别是在撤销偏向锁时,会导致所有线程暂停(Stop The World)。

在使用synchronized时,我们应该遵循减小锁粒度、避免对象共享、使用锁分离、使用锁粗化、使用锁消除等优化措施,并且只对需要同步的代码进行同步,避免在synchronized代码块中调用可能会阻塞的方法,以及避免死锁。

除了synchronized,Java还提供了其他的同步机制,如Lock、ReadWriteLock、Atomic等。这些机制在某些场景下可能会比synchronized更高效,因此我们应该根据具体的需求来选择合适的同步机制。

总的来说,synchronized是一种简单可靠的同步机制,但它也有其性能上的缺陷。为了写出高效且线程安全的Java程序,我们需要深入理解synchronized的原理,并且掌握其优化和最佳实践。同时,我们也应该了解Java中其他的同步机制,以便在不同的场景下选择最合适的解决方案。

6. 课后思考

  1. synchronized和ReentrantLock有什么区别?它们各自适用于哪些场景?
  2. synchronized是如何保证可见性的?它与volatile关键字有什么区别?
  3. 除了使用synchronized,还有哪些方式可以实现线程安全?它们各自有什么优缺点?
  4. 如何避免死锁?如果发生了死锁,应该如何诊断和解决?
  5. 在Java 8中,synchronized还有哪些新的优化?这些优化是如何实现的?

通过对这些问题的思考和探索,我们可以进一步加深对synchronized和Java并发编程的理解,写出更加高效且线程安全的Java程序。

avatar
文章
阅读
粉丝