Synchronized实现原理，你知道多少？

1.synchronized的作用是什么

synchronized也叫作同步锁，解决的是多个线程之间对资源的访问一致性。换句话说，就是保证在同一时刻，被synchronized修饰的方法或代码块只有一个线程在执行，其他线程必须等待，解决并发安全问题。

其可以支持原子性、可见性和有序性。三大特性的说明

2.synchronized的应用

2.1锁的分类

synchronized的锁可分为类锁和对象锁。

1）类锁

是用来锁类的，让所有对象共同争抢一把锁。一个类的所有对象共享一个class对象，共享一组静态方法，类锁的作用就是使持有者可以同步地调用静态方法。当synchronized修饰静态方法或者class对象的时候，拿到的就是类锁。

2）对象锁

是用来锁对象的，虚拟机为每个的非静态方法和非静态域都分配了自己的空间，每个对象各有一把锁，即同一个类如果有两个对象就有两把锁。synchronized修饰非静态方法或者this时拿到的就是对象锁。

2.2锁的应用

synchronized可用于方法和代码块。其中方法分为普通方法（非静态方法）和静态方法，而修饰代码块时又可以修饰类（xxx.class）和当前对象（this）。下面通过使用是否使用同步锁的现象来进行说明：

1）静态方法

先看下面的案例，这里使用两个线程对用一个数据进行操作，两次的结果理想值应该分别是10000和20000。（多了效果的直观性，这里循环此时比较大，每个测试方法建议运行多次，避免出现偶然的情况达到理想情况），打印结果一定是什么？

public class TestUtil{
    private static int i = 0;   //共享资源

    //基础方法，数字累加
    public static void baseMethod() {
        for (int j = 0; j < 10000; j++) {
            i++;
        }
        System.out.println(i);
    }

    //静态方法，没有使用同步锁
    public static void addS() {
        baseMethod();
    }
}

public class SynchronizedTest {

    public static void main(String[] args) {
        test1();
    }

    public static void test1() {
        new Thread(() -> {
            TestUtil.addS();
        }).start();
        new Thread(() -> {
            TestUtil.addS();
        }).start();
    }
}

打印结果，根据结果可以看出，并不是理想值，导致数据错乱。这就是典型的多线程问题，面对这样的问题，不得不加锁。这时，只需要在方法上加同步锁即可。

    //TestUtil
    public synchronized static void addS2() {
        baseMethod();
    } 

    //SynchronizedTest
    public static void test2() {
        new Thread(() -> {
            TestUtil.addS2();
        }).start();
        new Thread(() -> {
            TestUtil.addS2();
        }).start();
    }

运行test2()后结果已符合理想情况。

分析：当对静态方法加锁后，就使用了类锁，这个类的所有对象共享这个静态方法，这个方法就是同步方法。换句话说，就是当一个线程执行一个对象中的同步方法时，其他线程调用同一对象上的同步方法将会被阻塞，直到第一个线程完成使用这个对象。

2）普通方法

原始代码如下，工具类实现了Runnable接口（或继承Thread类，若不做此操作则无法看出效果）重写run方法

public class TestUtil implements Runnable{

    private static int i = 0;   //共享资源

    @Override
    public void run() {
        add();
    }

    //基础方法，数字累加
    public static void baseMethod() {
        for (int j = 0; j < 10000; j++) {
            i++;
        }
        System.out.println(i);
    }

    //非静态方法，没有使用同步锁
    public void add() {
        baseMethod();
    }
}

public class SynchronizedTest {

    public static void main(String[] args) {
        test3();
    }

    public static void test3() {
        TestUtil test = new TestUtil();
        new Thread(test).start();
        new Thread(test).start();
    }

    public static void test4() {
        TestUtil test = new TestUtil();
        TestUtil test2 = new TestUtil();
        new Thread(test).start();
        new Thread(test2).start();
    }
}

test3()运行结果，test4()的运行结果也是相似。这时，是不是只需要在方法上加同步锁就可以了呢？

    //TestUtil
    public synchronized void add2() {
        baseMethod();
    } 

    @Override
    public void run() {
        add2();
    }

加锁后并修改run方法中调用的方法名，运行test3()已符合理想情况。但test4()却还是错乱，都已经是同步方法了，这是为什么呢？其实很简单，对非静态方法加锁后，就使用了对象锁，对于test3()，两个线程都使用的同一个对象，自然是对这个对象加锁，从而保证数据的安全。而test4()创建了两个对象，两个线程使用的是两个对象，这两个对象分别只对自己加锁丝毫不影响别的对象的锁。自然会出现问题。那么究竟要怎么办呢？既然是使用的不同的锁，那么让它们使用同一把锁不就好了吗，只需要将这个非静态的同步方法改为静态同步方法即可。

3）同步代码块

所谓的同步代码块就是只对某一部分代码加锁，而不是对整个的方法加锁，因为若方法体比较大，涉及到同步的代码又只是一小部分，如果对方法加锁性能比较差。同步代码块可以对class对象（类锁）或this加锁（对象锁），下面以类锁进行说明

    @Override
    public void run() {
        //其他操作...

        //对象锁
//        synchronized (this) { }

        //类锁
        synchronized (TestUtil.class) {
            for (int j = 0; j < 10000; j++) {
                i++;
            }
        }
        System.out.println(i);
    }

在测试时虽然加了同步锁，但无论是调用test3()还是test4()都无法达到理想结果，第一次输出的值是变化的，第二次的值才是20000。为了解决这个问题，我们可以把需要加锁的那块代码抽出来，封装成静态方法，然后对该方法加锁，如下即可

同步静态方法需要对变量进行返回，原因很简单，就是在加锁的时候，还未释放锁，其他线程去获取的变量值可能不是最新的，只有当前释放锁后才会把最新的值返回。

3.synchronized底层实现原理

synchronized的底层实现是完全依赖JVM虚拟机的，所以先看看对象的存储结构。

3.1对象结构

JVM是虚拟机，是一种标准规范，主要作用就是运行java的类文件的。而虚拟机有很多实现版本，HotSpot就是虚拟机的一种实现，是基于热点代码探测的，有JIT即时编译功能，能提供更高质量的本地代码。HotSpot 虚拟机中对象在内存中可分为对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。其组成结构如下图：

1）实例数据：存放类的属性数据信息，包括父类的属性信息。如果是数组，那么实例部分还包括数组的长度，这部分内存按4字节对齐。

2）对齐填充：虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐。

3）对象头

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

对于标记字段，用于存储对象自身的运行时数据，其组成如下图

（锁信息占3位）在jdk1.6之前只有重量级锁，而1.6后对其进行了优化，就有了偏向锁和轻量级锁。

3.2上锁的原理

对于同步代码块来说，主要使用monitor(监视器)实现的，就相当于一个房间一次只能被允许一个进程进入。主要包含monitorenter和monitorexit。其中monitorenter指向同步代码块开始的位置，monitorexit指向同步代码块结束的位置。当执行monitorenter时，线程试图monitor的持有权，当monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。若其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。当执行monitorexit时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor。

对于同步方法来说，使用的是ACC_SYNCHRONIZED 标识，通过该标识指明该方法是否是一个同步方法。

3.3锁升级

所谓的上锁，就是把锁的信息记录在对象头中，默认是无锁的，当达到一定的条件时会进行锁升级，会按照下面的顺序依次升级。

• 无锁：没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功。
• 偏向锁：作用是消除数据在无竞争情况下的同步原语，进一步提高程序的性能。大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。偏向锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要同步（使用同步锁的情况下）。
• 轻量级锁：当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞。目的是在没有多线程竞争的情况下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗，从而提高性能。
• 重量级锁：指的是原始的Synchronized的实现，当使用同步锁后，其他线程试图获取锁时，都会被阻塞，只有持有锁的线程释放锁之后才会唤醒这些线程。

如何查看对象的信息呢？下面以User对象进行说明：

①User对象

public class User {
    public String name;
    private String pwd;
    private Integer age;
   //get，set等方法在此省略
}

②导入依赖，用于获取对象头信息

        <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.10</version>
        </dependency>

③打印对象信息

package com.zxh.demo;

import com.zxh.demo.entity.User;
import org.openjdk.jol.info.ClassLayout;

public class LockTest {

    public static void main(String[] args) {
        User user = new User();
        System.out.println("对象结构：(格式化)");
        System.out.println(ClassLayout.parseInstance(user).toPrintable());
    }
}

打印结果如下：

其中A和B区域是对象头信息，C是对象的成员变量（包含了默认值）。而A就是mark-down的信息，B是元数据指针。对A来说，有两行，也就是64位，但是在看二进制时需要反过来看。比如上述64位正常情况下拼接（00000001 00000000 00000000 00000000 00000000 00000000 00000000 00000000），但实际时应该是（00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001），因此最后的八位在上述mark-down图中就是最后面的8位，那么对于锁信息就是001，也就是无锁。

那么怎么将锁升级为偏向锁呢？JVM默认延时超过4s会开启偏向锁，也可以在程序启动时去指定。这里通过程序休眠的方式去开始偏向锁：

    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(5000);
        User user = new User();
        System.out.println("启用偏向锁");
        System.out.println(ClassLayout.parseInstance(user).toPrintable());
        for (int i = 0; i < 2; i++) {
            synchronized (user) {
                System.out.println("偏向锁101：" + ClassLayout.parseInstance(user).toPrintable());
            }
            System.out.println("释放偏向锁 ：" + ClassLayout.parseInstance(user).toPrintable());
        }
    }

从下面的运行结果可以看出，启用偏向锁后，升级为偏向锁（锁信息为101），对象头中就记录了线程的id

虽然在代码中释放了偏向锁，但对象头中的信息不会改变，原因是偏向锁不会主动释放，方便同一个线程下次直接去执行被加锁的代码块。

此时，如果再加入线程对对象加锁，那么立马就会变为轻量级锁：

    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(5000);
        User user = new User();
        System.out.println("启用偏向锁");
        System.out.println(ClassLayout.parseInstance(user).toPrintable());
        for (int i = 0; i < 2; i++) {
            synchronized (user) {
                System.out.println("偏向锁101：" + ClassLayout.parseInstance(user).toPrintable());
            }
            System.out.println("释放偏向锁 ：" + ClassLayout.parseInstance(user).toPrintable());
        }
        new Thread(()->{
            synchronized (user) {
                System.out.println("轻量级锁000：" + ClassLayout.parseInstance(user).toPrintable());
            }
        }).start();
    }
}

运行结果部分截图：

此时，如果还有其他线程继续对此对象加锁（必要时可加延时），那么就会升级为重量级锁：

    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(5000);
        User user = new User();
        System.out.println("启用偏向锁");
        System.out.println(ClassLayout.parseInstance(user).toPrintable());
        for (int i = 0; i < 2; i++) {
            synchronized (user) {
                System.out.println("偏向锁101：" + ClassLayout.parseInstance(user).toPrintable());
            }
            System.out.println("释放偏向锁 ：" + ClassLayout.parseInstance(user).toPrintable());
        }
        new Thread(()->{
            synchronized (user) {
                System.out.println("轻量级锁000：" + ClassLayout.parseInstance(user).toPrintable());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("轻量级锁-> 重量级锁：" + ClassLayout.parseInstance(user).toPrintable());
            }
        }).start();
        Thread.sleep(1000);
        new Thread(()->{
            synchronized (user) {
                System.out.println("重量级锁010：" + ClassLayout.parseInstance(user).toPrintable());
            }
        }).start();
    }

运行结果部分截图：

因此，锁升级的原理是：默认情况下是无锁的，此时对象头中threadId的值为空，但在手动开始或延迟4秒后会进入偏向锁。在进入偏向锁时，会将threadId设置为此线程的id，那么当线程再次进入时 ，会判断此线程的id是否和threadId一致。如果一致则可以直接使用此对象，若不一致（有其他线程进入）则会升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁。如果执行一定次数后还没有正常获取到要使用的对象，则会升级轻量级锁为重量级锁。