杰霸霸博客

主题

Synchronized关键字 ​

1. 作用范围 ​

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
  2. 修饰一个普通方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
  3. 修饰一个静态方法，其作用的范围是整个静态方法，锁是当前类的Class对象。

提示

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加synchronized关键字才可以。当然还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此子类的方法也就相当于同步了。

  1. 修改一个静态代码块类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。

2. 使用synchronized ​

多线程编程步骤：
第一步, 创建资源类，在资源类创建属性和操作方法。
第二步, 创建多个线程，调用资源类的操作方法。

java
public class Demo {
    // 1. 创建资源类，在资源类创建属性和操作方法。 
    static class Ticketer {
        private int num = 30;
        public synchronized void sale() {
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "卖了1张, 还剩" + --num);
            }
        }
    }

    public static void main(String[] args) {

        Ticketer ticketer = new Ticketer();
        // 2. 创建多个线程，调用资源类的操作方法
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticketer.sale();
            }
        }).start();
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticketer.sale();
            }
        }).start();
        Thread t3 = new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticketer.sale();
            }
        }).start();
    }
}

运行结果：
Alt text 如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

  1. 获取锁的线程执行完了该代码块，然后线程释放对锁的占有
  2. 线程执行发生异常，此时JVM会让线程自动释放锁

那么如果这个获取锁的线程由于要等待IO或者其他原因(比如调用sleep方法)被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去(比如只等待一定的时间或者能够响应中断)，通过Lock就可以办到。

3. synchronized的基本原理 ​

synchronized关键字用于对某个对象的监视器（Monitor）加锁，确保在同一时刻只有一个线程可以执行同步代码块或同步方法。每个对象在Java中都有一个关联的监视器锁。

3.1 对象锁与监视器 ​

在Java中，每个对象都有一个监视器锁（Monitor）。当线程进入sychronized块时，它必须首先获取与该对象关联的监视器锁。一旦获得锁，其他线程就不能再获得该锁，直到锁被释放。监视器锁是实现线程同步的基础，它确保了在同一时刻只有一个线程可以访问同步资源。Java虚拟机使用监视器来实现synchronized机制，监视器是基于操作系统的互斥量（mutex）或信号量实现的。

3.2 锁的获取与释放 ​

synchronized块或方法的锁获取和释放是隐式的：

  • 锁的获取：当线程进入sychronized块或方法时，它尝试获取目标对象的监视器锁。如果锁已经被其他线程持有，则当前线程会进入阻塞状态，直到锁可用。
  • 锁的释放：当线程退出synchronized块或方法时，它会自动释放所持有的锁，使其他线程可以继续尝试获取锁。

4. synchronized的可重入性原理 ​

synchronized的可重入性是由监视器锁的计数器来实现的。当一个线程获取一个对象的锁时，锁的计数器会加1；当线程退出同步块或方法时，计数器会减1。如果计数器为0，则表示锁已被释放。

4.1 计数器的工作原理 ​

  1. 第一次获取锁：当线程第一次进入synchronized块或方法时，监视器锁的计数器从0增加到1，并记录当前持有锁的线程ID。
  2. 再次获取锁：如果该线程在持有锁的情况下再次进入另一个synchronized块或方法，计数器会再次增加，表明线程多次获取了同一个锁。
  3. 锁的释放：每当线程退出synchronized块或方法时，计数器会减少。当计数器减少到0时，锁被真正释放，其他线程可以获取该锁。

4.2 示例分析 ​

java
public class ReentrantLockExample {
    public synchronized void method1() {
        System.out.println("Inside method1");
        method2(); // 线程再次获取同一个锁
    }

    public synchronized void method2() {
        System.out.println("Inside method2");
        // 线程可以再次进入method1，因为锁是可重入的
        method1();
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.method1();
    }
}

在这个例子中，method1和method2相互调用，由于synchronized是可重入的，线程可以多次进入同步代码块而不会发生死锁。每次线程重新进入同步方法，锁的计数器都会递增。当线程退出同步方法时，计数器递减，直到计数器为0时，锁才会被真正释放。

4.3 synchronized的底层实现 ​

synchronized的可重入性主要依赖于JVM中的监视器锁机制。Java编译器在编译sychronized方法或代码块时，会在字节码中插入特定的指令，以便JVM能够管理锁的获取和释放。

4.4 monitorenter和monitorexit指令 ​

在字节码层面，synchronized块通过monitorenter和monitorexit指令来实现：
monitorenter：指令在线程进入同步代码块时执行，尝试获取对象的监视器锁。如果锁不可用，线程会阻塞，直到锁可用。
monitorexit：指令在线程退出同步代码块时执行，释放监视器锁。如果线程重新进入同一个同步代码块或方法，多次执行monitorenter时，JVM会递增锁的计数器。

5. JVM中的锁实现 ​

JVM中，监视器锁的实现是基于操作系统的互斥量或信号量机制，这些机制提供了底层的锁定和同步功能。JVM通过这些底层机制来确保synchronized的正确性和可重入性。
当一个线程获取一个锁时，JVM会记录该线程的ID，并递增锁的计数器。只有当持有锁的线程试图再次获取锁时，计数器才会继续递增。其他线程试图获取该锁时会被阻塞，直到持有锁的线程释放锁。

6. synchronized的可重入性意义 ​

synchronized的可重入性对于简化编程和避免死锁具有重要意义。在实际开发中，方法调用的嵌套和递归是常见的场景，如果sychronized不支持可重入性，那么在这种情况下会导致线程阻塞，甚至引发死锁。
例如，很多框架和库中，使用了大量的递归调用和同步操作。sychronized的可重入性确保了这些操作可以安全地执行，而不会因为重复获取同一锁而导致问题。