一、什么是synchronized

在Java当中synchronized通常是用来标记一个方法或者代码块。在Java当中被synchronized标记的代码或者方法在同一个时刻只能够有一个线程执行被synchronized修饰的方法或者代码块。因此被synchronized修饰的方法或者代码块不会出现数据竞争的情况，也就是说被synchronized修饰的代码块是并发安全的。synchronized是java内置关键字,是内置锁,JVM中内置了,颗粒度比较大

二、synchronized的四种用法

2.1、修饰一个代码块

被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象;

2.2、修饰一个方法

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

非静态方法使用 synchronized 修饰的写法，修饰实例方法时，锁定的是当前实例对象：

2.3、修饰一个静态的方法

其作用的范围是整个静态方法，作用的对象是这个类的所有对象;

2.4、修饰一个类

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

三、使用案例分析

3.1、修饰一个方法

class SyncDemo {
    private int count;

    public void add() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        SyncDemo syncDemo = new SyncDemo();
        Thread t1 = new Thread(()->{
            for (int i = 0; i <1000 ; i++) {
                syncDemo.add();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i <1000 ; i++) {
                syncDemo.add();
            }
        });
        t1.start();
        t2.start();
        t1.join();  //线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句
        t2.join();  //线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句
        System.out.println(syncDemo.count);
    }
}

由于add方法没有使用synchronized修饰，线程t1和线程t2可能同时去执行add方法，那么就会导致最终count的结果小于20000，因为count++操作不具备原子性。 

将上述add方法被synchronized修饰

 public synchronized void add() {
        count++;
  }

由于add方法被synchronized修饰,因此每一个时刻只能有一个线程执行add方法，因此上面打印的结果是20000

总结: 

synchronized修饰的add方法一个时刻只能有一个线程执行的意思是对于一个SyncDemo类的对象来说一个时刻只能有一个线程进入。比如现在有两个SyncDemo的对象s1和s2，一个时刻只能有一个线程进行s1的add方法，一个时刻只能有一个线程进入s2的add方法，但是同一个时刻可以有两个不同的线程执行s1和s2的add方法，也就说s1的add方法和s2的add是没有关系的，一个线程进入s1的add方法并不会阻止另外的线程进入s2的add方法，也就是说synchronized在修饰一个非静态方法的时候“锁”住的只是一个实例对象，并不会“锁”住其它的对象。其实这也很容易理解，一个实例对象是一个独立的个体别的对象不会影响他，他也不会影响别的对象。

3.2、修饰一个静态的方法

class SyncDemo {
    private static int count;  //静态变量
    public static synchronized void add() { //静态方法
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        SyncDemo syncDemo = new SyncDemo();
        Thread t1 = new Thread(()->{
            for (int i = 0; i <1000 ; i++) {
                syncDemo.add();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i <1000 ; i++) {
                syncDemo.add();
            }
        });
        t1.start();
        t2.start();
        t1.join();  //线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句
        t2.join();  //线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句
        System.out.println(syncDemo.count);  //输出结果为2000
    }
}

上面的代码最终输出的结果也是20000，但是与前一个程序不同的是。这里的add方法用static修饰的，在这种情况下真正只能有一个线程进入到add方法，因为用static修饰的add方法是静态方法,静态方法所有对象公共的方法，因此和前面的那种情况不同，不存在两个不同的线程同一时刻执行不同实例对象的add方法。

你仔细想想如果能够让两个不同的线程执行add代码块，那么count++的执行就不是原子的了。那为什么没有用static修饰的代码为什么可以呢？因为当没有用static修饰时，每一个对象的count都是不同的，内存地址不一样，因此在这种情况下count++这个操作仍然是原子的！

3.3、修饰一个代码块

class SyncDemo {
    private  int count;  //静态变量
    public  void add() {
        System.out.println("进入了add方法");
        synchronized (this){
            count++;
        }
    }
    public  void minus() {
        System.out.println("进入了minus方法");
        synchronized (this){
            count--;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        SyncDemo syncDemo = new SyncDemo();
        Thread t1 = new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                syncDemo.add();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                syncDemo.minus();
            }
        });
        t1.start();
        t2.start();
        t1.join();  //线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句
        t2.join();  //线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句
        System.out.println(syncDemo.count);  //输出结果为0
    }
}

有时候我们并不需要用synchronized去修饰一个方法，因为这样并发度就比较低了，一个方法一个时刻只能有一个线程在执行。因此我们可以选择用synchronized去修饰代码块，只让某个代码块一个时刻只能有一个线程执行，除了这个代码块之外的代码还是可以并行的。

比如上面的代码当中add和minus方法没有使用synchronized进行修饰，因此一个时刻可以有多个线程执行这个两个方法。在上面的synchronized代码块当中我们使用了this对象作为锁对象，只有拿到这个锁对象的线程才能够进入代码块执行，而在同一个时刻只能有一个线程能够获得锁对象。也就是说add函数和minus函数用synchronized修饰的两个代码块同一个时刻只能有一个代码块的代码能够被一个线程执行，因此上面的结果同样是0。

这里说的锁对象是this也就SyncDemo类的一个实例对象，因为它锁住的是一个实例对象，因此当实例对象不一样的时候他们之间是没有关系的，也就是说不同实例用synchronized修饰的代码块是没有关系的，他们之间是可以并发的。

3.4、修饰一个类

class SyncDemo {
    private  int count;  //静态变量
    public  void add() {
        System.out.println("进入了add方法");
        synchronized (SyncDemo.class){
            count++;
        }
    }
    public  void minus() {
        System.out.println("进入了minus方法");
        synchronized (SyncDemo.class){
            count--;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        SyncDemo syncDemo = new SyncDemo();
        Thread t1 = new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                syncDemo.add();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                syncDemo.minus();
            }
        });
        t1.start();
        t2.start();
        t1.join();  //线程的阻塞方法,线程t1执行完毕,再执行main主线程打印语句
        t2.join();  //线程的阻塞方法,线程t2执行完毕,再执行main主线程打印语句
        System.out.println(syncDemo.count);  //输出结果为0
    }
}

上面的代码是使用synchronized修饰类，锁对象是SyncDemo.class,这个时候他不再是锁住一个对象了，而是一个类了，这个时候的并发度就变小了，上一份代码当锁对象是SyncDemo的实例对象时并发度更大一些，因为当锁对象是实例对象的时候，只有实例对象内部是不能够并发的，实例之间是可以并发的。但是当锁对象是SyncDemo.class的时候，实例对象之间时不能够并发的，因为这个时候的锁对象是一个类。

四、Synchronized与可见性和重排序

4.1互斥性/排他性(非公平锁)

synchronized（非公平锁）会起到互斥效果，某个线程执⾏到某个对象的 synchronized 中时，其他线程如果也执⾏到同⼀个对象 synchronized 就会阻塞等待。

• 进⼊ synchronized 修饰的代码块, 相当于加锁。
• 退出 synchronized 修饰的代码块, 相当于解锁。

PS：公平锁 VS 非公平锁
公平锁：按资排辈，先到先得。需要“唤醒”这一步操作，会牺牲一定的性能。(线程发现锁占用，尝试获取锁一段时间后，进入休眠状态，进入排队队列中等待。上一个线程释放锁后，会唤醒排队等候的其他线程中最前面的线程从阻塞状态又切换至运行状态）
非公平锁：来得早不如来得巧，不需要“唤醒”，性能高。（线程1发现锁占用，尝试获取锁一段时间后，进入休眠状态。此时线程2来了，处于运行状态，尝试获取锁，此时刚好上一个线程释放了锁，那么线程2直接得到了锁并去运行它的任务了。排队等待的其他线程获取锁的顺序不是按照访问的顺序先来先到的，而是由线程自己竞争，随机获取到锁）Java里所有的锁默认是非公平锁。

4.2可见性

• 当一个线程进入到synchronized同步代码块的时候，将会刷新所有对该线程的可见的变量，也就是说如果其他线程修改了某个变量，而且线程需要在Synchronized代码块当中使用，那就会重新刷新这个变量到内存当中，保证这个变量对于执行同步代码块的线程是可见的。

• 当一个线程从同步代码块退出的时候，也会将线程的工作内存同步到内存当中，保证在同步代码块当中修改的变量对其他线程可见。

4.3可重入性(可重入性锁)

synchronized 同步块对同⼀条线程来说是可重⼊的，不会出现⾃⼰把⾃⼰锁死的问题。

/**
 * synchronized 可重入性测试
 */
public class ThreadSynchronized4 {
    public static void main(String[] args) {
        synchronized (ThreadSynchronized4.class) {
            System.out.println("当前主线程已经得到了锁"); //当执行到此行代码时，表示已经获得锁
            synchronized (ThreadSynchronized4.class) { //同一个线程获取锁两次
                System.out.println("当前主线程再次得到了锁"); //若两行代码都能打印，说明具备可重入性
            }
        }
    }
}

 

五、synchronized实现原理

（面试必问）synchronized是如何实现的？
①在Java代码层面：

synchronized加锁的对象里有一个的隐藏的对象头，这个对象头（可看作一个类）里有很多属性，其中比较关注的两个属性是：是否加锁的标识和拥有当前锁的线程id。

每次进⼊ synchronized 修饰的代码块时，会去对象头中先判断加锁的标识，再判断拥有当前锁的线程id，从而决定当前线程能否往下继续执行。

判断加锁标识为false->对象头未加锁，当前线程可以进入synchronized 修饰的代码块，并设置加锁标识为true，设置拥有当前锁的线程id为此线程id。
判断加锁标识为true->对象头已加锁，需进一步判断拥有当前锁的线程id是否为此线程id，若是，则继续往下执行；否则，不能往下执行，需要等待锁资源释放后重新竞争再获取锁。
②在JVM层面和操作系统层面：

synchronized同步锁是通过JVM内置的Monitor监视器实现的，而监视器又是依赖操作系统的互斥锁Mutex实现的。↓
————————————————
原文链接：https://blog.csdn.net/WWXDwrn/article/details/129115774

六、synchronized历史发展进程

• 在JDK1.6之前（多使用Lock）synchronized使用很少，那时synchronized默认使用重量级锁实现，所以性能较差。
• 在JDK1.6时，synchronized做了优化。锁升级流程如下：

1,无锁：没有线程访问时默认是无锁状态，加了synchronized也是无锁状态。有线程访问时才加锁。更大程度上减少锁带来的程序上的开销。
2,偏向锁：当有一个线程访问时会升级为偏向锁。(在对象头里存了这样一把锁，后面再来线程时会判断，如果线程id和拥有锁的线程id相同，会让它进去，只偏向某一个线程，其他线程来了之后要继续等)
3,轻量级锁：当有多个线程访问时会升级为轻量级锁。
4,重量级锁：当大量线程访问同时竞争锁资源的时候会升级为重量级锁。

原文链接：https://baijiahao.baidu.com/s?id=1740505389877266267&wfr=spider&for=pc