Java基础之Synchronized原理

目录
synchronized的三种应用方式
synchronized作用于实例方法
synchronized作用于静态方法
synchronized同步代码块
synchronized底层语义原理
理解Java对象头与Monitor
synchronized代码块底层原理
synchronized方法底层原理
Java虚拟机对synchronized的优化
偏向锁
轻量级锁
自旋锁
锁消除
无锁->偏向锁
偏向锁 -> 轻量级锁
轻量级锁 -> 重量级锁
关于synchronized 可能需要了解的关键点
synchronized的可重入性
线程中断与synchronized
线程中断
等待唤醒机制与synchronized
在多线程使用共享资源的时候， 我们可以使用synchronized来锁定共享资源，使得同一时刻，只有一个线程可以访问和修改它，修改完毕后，其他线程才可以使用。这种方式叫做互斥锁。

当一个共享数据被当前正在访问到线程添加了互斥锁之后，在同一时刻，其他线程只能等待，直到当前线程释放该锁。

synchronized可以添加互斥锁，并且保证被其他线程看到。

synchronized的三种应用方式
synchronized关键字最主要有以下3种应用方式，下面分别介绍

修饰实例方法，作用于当前实例加锁，进入同步代码钱要获得当前实例的锁
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁
synchronized作用于实例方法
我们设置类变量static为共享资源， 然后多个线程去修改。修改的含义是： 先读取，计算，再写入。那么这个过程就不是原子的，多个线程操作就会出现共享资源争抢问题。

我们在实例方法上添加synchronized，那么，同一个实例执行本方法时，抢到锁到可以执行。

public class AccountingSync implements Runnable{
//共享资源(临界资源)
static int i=0;

/**
 * synchronized 修饰实例方法
 */
public synchronized void increase(){
    i++;
}
@Override
public void run() {
    for(int j=0;j<1000000;j++){
        increase();
    }
}
public static void main(String[] args) throws InterruptedException {
    AccountingSync instance=new AccountingSync();
    Thread t1=new Thread(instance);
    Thread t2=new Thread(instance);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(i);
}
/**
 * 输出结果:
 * 2000000
 */

}
上述代码中，开启两个线程去操作共享变量，两个线程执行的是同一个实例对象。如果不添加synchronized，其中i++不是原子操作，该操作先读取值，然后再写入一个新值。如果两个线程都读取了i=5，然后线程1写入i=6.线程2后写入，但也是写入i=6, 并不是我们期望的i=7.

添加synchronized修饰后，线程安全，线程必须获取到这个实力到锁才能执行读取和写入。

注意，我们synchronized修饰到是类方法，锁的是实例，当多个线程操作不同实例时，会使用不同实例的锁，就无法保证修改static变量的有序性了。

public class AccountingSyncBad implements Runnable{
static int i=0;
public synchronized void increase(){
i++;
}
@Override
public void run() {
for(int j=0;j<1000000;j++){
increase();
}
}
public static void main(String[] args) throws InterruptedException {
//new新实例
Thread t1=new Thread(new AccountingSyncBad());
//new新实例
Thread t2=new Thread(new AccountingSyncBad());
t1.start();
t2.start();
//join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
t1.join();
t2.join();
System.out.println(i);
}
}
上述代码，两个线程持有不同的对象instance，也就是使用不同的锁， 也就不会互斥访问共享资源，就会出现线程安全问题。

synchronized作用于静态方法
synchronized作用于静态方法时，锁就是当前类到class对象锁。由于静态成员变量不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。

synchronized同步代码块
除了使用关键字修饰实例方法和静态方法外，还可以使用同步代码块。

public class AccountingSync implements Runnable{
static AccountingSync instance=new AccountingSync();
static int i=0;
@Override
public void run() {
//省略其他耗时操作…
//使用同步代码块对变量i进行同步操作,锁对象为instance
synchronized(instance){
for(int j=0;j<1000000;j++){
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(instance);
Thread t2=new Thread(instance);
t1.start();t2.start();
t1.join();t2.join();
System.out.println(i);
}
}

上述代码，将synchronized作用于一个给定的实例对象instance, 即当前实例对象就是锁对象，每次当线程进入synchronized包裹到代码块时，就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到到线程就必须等待，这样也就保证了每次只有一个线程执行i++操作。当然， 还可以使用this或者class

//this,当前实例对象锁
synchronized(this){
for(int j=0;j<1000000;j++){
i++;
}
}

//class对象锁
synchronized(AccountingSync.class){
for(int j=0;j<1000000;j++){
i++;
}
}
了解完synchronized到基本含义和使用方式后，我们进一步深入理解synchronized的底层实现原理。

synchronized底层语义原理
Java虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现，无论是显示同步(有明确的monitorenter和monitorexit指令，即同步代码块)还是隐式同步都是如此。在Java语言中，同步用的最多到地方可能是被synchronized修饰的同步方法。同步方法并不是由monitorenter和monitorexit指令来实现同步到，而是由方法调用指令读取运行时常量池中方法到ACC_SYNCHRONIZED标志来隐式实现的，关于这点，稍后分析。下面先来了解一个概念：Java对象头，这对深入理解synchronized实现原理非常关键。

理解Java对象头与Monitor
在JVM中，对象在内存中到布局分为三块区域：对象头，实例数据和对齐填充。 如下：

实例变量： 存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。
填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐。