synchronized的原理与四种用法介绍

介绍

JDK提供的锁分两种，一种是JVM实现的synchronized，是java的关键字，因此在这个关键字作用对象的范围内都是可以保证原子性的，主要是依赖特殊的CPU指令。另一种是JDK提供的代码层面的锁Lock。

一、synchronized的四种用法

1. 修饰代码块

大括号括起来的代码，称同步语句块，作用范围是大括号，作用对象是调用代码块的对象。

public void test1(int j) {
    synchronized (this) {
        for (int i = 0; i < 10; i++) {
            log.info("test1 {} - {}", j, i);
        }
    }
}

测试代码：

public static void main(String[] args) {
    SynchronizedExample1 example1 = new SynchronizedExample1();
    SynchronizedExample1 example2 = new SynchronizedExample1();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() - > {
        example1.test1(1);
    });
    executorService.execute(() - > {
        example2.test1(2);
    });
}

测试结果：

• 可以看到test1方法的参数1和参数2是交替执行。

2. 修饰方法

被修饰的方法称为同步方法，作用范围是整个方法，作用于调用对象。

public synchronized void test2(int j) {
    for (int i = 0; i < 10; i++) {
        log.info("test2 {} - {}", j, i);
    }
}

测试代码：

public static void main(String[] args) {
    SynchronizedExample1 example1 = new SynchronizedExample1();
    SynchronizedExample1 example2 = new SynchronizedExample1();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() - > {
        example1.test2(1);
    });
    executorService.execute(() - > {
        example2.test2(2);
    });
}

测试结果：

• 可以看到test2方法的参数1和参数2是交替执行。

3. 修饰静态方法

作用范围是整个方法，作用于所有对象。

public static synchronized void test3(int j) {
    for (int i = 0; i < 10; i++) {
        log.info("test3 {} - {}", j, i);
    }
}

测试代码：

public static void main(String[] args) {
    SynchronizedExample1 example1 = new SynchronizedExample1();
    SynchronizedExample1 example2 = new SynchronizedExample1();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() - > {
        example1.test3(1);
    });
    executorService.execute(() - > {
        example2.test3(2);
    });
}

测试结果：

• 可以看到test3方法的参数1和参数2是1执行完才执行的2。

4. 修饰类

作用范围是synchronized后面括号括起来的部分，作用于所有对象。

public static void test4(int j) {
    synchronized (SynchronizedExample2.class) {
        for (int i = 0; i < 10; i++) {
            log.info("test4 {} - {}", j, i);
        }
    }
}

测试代码：

public static void main(String[] args) {
    SynchronizedExample1 example1 = new SynchronizedExample1();
    SynchronizedExample1 example2 = new SynchronizedExample1();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() - > {
        example1.test4(1);
    });
    executorService.execute(() - > {
        example2.test4(2);
    });
}

测试结果：

• 可以看到test4方法的参数1和参数2是1执行完才执行的2。

二、synchronized的原理

在Java语言中存在两种内建的synchronized语法：synchronized语句、synchronized方法：

• synchronized语句：当源代码被编译成字节码的时候，会在同步块的入口位置和退出位置分别插入monitorenter和monitorexit字节码指令。
• synchronized方法：在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1

synchronized语句

如上示例，test1和test4使用的就是synchronized语句。使用Javap -c命令反编译test1代码，如下：

在Java虚拟机的specification中，有关于monitorenter和monitorexit字节码指令的详细描述：

monitorenter

每个对象都有一个锁，也就是监视器（monitor）。 Monitor可以理解为一个同步工具或一种同步机制，通常被描述为一个对象。 每一个Java对象就有一把看不见的锁，称为内部锁或者Monitor锁。

当monitor被占有时就表示它被锁定。线程执行monitorenter指令时尝试获取对象所对应的monitor的所有权，过程如下：

• 如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
• 如果线程已经拥有了该monitor，只是重新进入，则进入monitor的进入数加1。
• 如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

monitorexit

执行monitorexit的线程必须是相应的monitor的所有者。指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个monitor的所有权。

synchronized方法

如上示例，test2和test3使用的就是synchronized方法。synchronized方法加锁的方式是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1。如下：

• 访问标志的第11位即为加锁标记位。

三、synchronized的优化

synchronized在操作同步资源之前需要给同步资源先加锁，这把锁就是存在Java对象头里，而Java对象头又是什么呢？

Java对象头

以Hotspot虚拟机为例，Hotspot的对象头主要包括两部分数据：Mark Word（标记字段）、Klass Pointer（类型指针）。

Mark Word

默认存储对象的HashCode，分代年龄和锁标志位信息。这些信息都是与对象自身定义无关的数据，所以Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据。它会根据对象的状态复用自己的存储空间，也就是说在运行期间Mark Word里存储的数据会随着锁标志位的变化而变化。

Klass Point

对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

在JDK1.6及其之前的版本中monitorenter和monitorexit字节码依赖于底层的操作系统的Mutex Lock来实现的，但是由于使用Mutex Lock需要将当前线程挂起并从用户态切换到内核态来执行，这种切换的代价是非常昂贵的。然而在现实中的大部分情况下，同步方法是运行在单线程环境（无锁竞争环境）。如果每次都调用Mutex Lock将严重的影响程序的性能。因此在JDK6中为了减少获得锁和释放锁带来的性能消耗，引入了偏向锁和 轻量级锁 。所以目前锁一共有4种状态，级别从低到高依次是：无锁、偏向锁、轻量级锁和重量级锁。锁状态只能升级不能降级。如下：

无锁

• 无锁没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功。
• 无锁的特点就是修改操作在循环内进行，线程会不断的尝试修改共享资源。如果没有冲突就修改成功并退出，否则就会继续循环尝试。如果有多个线程修改同一个值，必定会有一个线程能修改成功，而其他修改失败的线程会不断重试直到修改成功。

偏向锁

• 偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价。
• 引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，其目标就是在只有一个线程执行同步代码块时能够提高性能。
• 当一个线程访问同步代码块并获取锁时，会在Mark Word里存储锁偏向的线程ID。在线程进入和退出同步块时不再通过CAS操作来加锁和解锁，而是检测Mark Word里是否存储着指向当前线程的偏向锁。
• 偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动释放偏向锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态。撤销偏向锁后恢复到无锁或轻量级锁的状态。
• 偏向锁在JDK 6及以后的JVM里是默认启用的。可以通过JVM参数关闭偏向锁： -XX:-UseBiasedLocking=false ，关闭之后程序默认会进入轻量级锁状态。

轻量级锁

• 是指当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，从而提高性能。
• 在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为01状态，是否为偏向锁为0），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝，然后拷贝对象头中的Mark Word复制到锁记录中。
• 拷贝成功后，虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，并将Lock Record里的owner指针指向对象的Mark Word。
• 如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位设置为00，表示此对象处于轻量级锁定状态。
• 如果轻量级锁的更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明多个线程竞争锁。

重量级锁

• 若当前只有一个等待线程，则该线程通过自旋进行等待。但是当自旋超过一定的次数，或者一个线程在持有锁，一个在自旋，又有第三个来访时，轻量级锁升级为重量级锁。
• 升级为重量级锁时，锁标志的状态值变为10，此时Mark Word中存储的是指向重量级锁的指针，此时等待锁的线程都会进入阻塞状态。

综上，偏向锁通过对比Mark Word解决加锁问题，避免执行CAS操作。而轻量级锁是通过用CAS操作和自旋来解决加锁问题，避免线程阻塞和唤醒而影响性能。重量级锁是将除了拥有锁的线程以外的线程都阻塞。

四、synchronized存在的问题

1.性能损耗

• 虽然在JDK 1.6中对synchronized做了很多优化，如如适应性自旋、锁消除、锁粗化、轻量级锁和偏向锁等，但毕竟还是一种锁。
• 所以，无论是使用同步方法还是同步代码块，在同步操作之前还是要进行加锁，同步操作之后需要进行解锁，这个加锁、解锁的过程是要有性能损耗的。

2. 阻塞

• synchronize实现的锁本质上是一种阻塞锁，多个线程要排队访问同一个共享对象。