一：基本概念

Synchronized：是JVM层次上的锁（监视器锁），可重入，非公平锁。

synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

二：项目中怎么使用

项目中使用：修饰实例方法，修饰静态方法，修饰同步代码块

修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份）。所以如果一个线程 A 调用一个实例对象的非静态 synchronized 方法，而线程 B 需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。
修饰代码块: 指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

总结：

synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。synchronized 关键字加到实例方法上是给对象实例上锁。尽量不要使用 synchronized(String a) 因为JVM中，字符串常量池具有缓存功能！

手写一个双检锁的单例模式

class DemoTest {// 懒加载
    // volatile 防止指令重排
    private static volatile DemoTest demotest;
    // 私有化构造
    private DemoTest(){
        
    }
    // 获取实例化对象函数
    private static DemoTest getInstance(){
        // 先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if(demotest == null){
           // 类对象加锁
            synchronized(DemoTest.class){
                if(demotest == null){
                    /**
                    * demotest = new DemoTest(); 
                    * 这段代码其实是分为三步执行：
                    * 1:为 uniqueInstance 分配内存空间
                    * 2:初始化 uniqueInstance
                    * 3:将 uniqueInstance 指向分配的内存地址
                    * 指令重排，可能导致执行顺序是1-3-2
                    * 线程 T1 执行了 1 和 3，
                    * 此时 T2 调用 getInstance() 后发现 demotest 不为空，
                    * 因此返回 demotest ，但此时 demotest 还未被初始化。
                    */
                    demotest = new DemoTest();
                }
            }
            
        }
        return demotest;
    }
    
}

总结：

可以概括为，多线程并发情况下，加入volatile修饰，可以避免指令重排引起的获取到未实例化的对象。详细可看我的另外一篇文章：并发编程（一）：volatile关键字

三：底层实现

private synchronized static void demoMethod(){
    System.out.println("静态同步方法");
}

public void mothod(){
    synchronized (this){
        System.out.println("同步代码块");
    }
}

查看Class文件对应的指令；

javap -c -s DemoTest.class

monitor指令实现了Synchronized的线程同步：首先monitorenter指令，会将计数器设置为1，而monitorexit指令是将计数器设置为0，当计数器值为0时表示未获取锁，且可以获取锁；通过这样的方式来实现代码块的线程同步。

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

FloatCloud

synchronized修饰同步方法：是通过ACC_SYNCHRONIZED访问标志来判断该方法是否是同步方法，执行响应的同步调用操作。

四：JDK1.6 之后的synchronized 关键字底层做了哪些优化

JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。

锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

具体相关锁的介绍，后续文章会进行讲解。

五：synchronized和ReentrantLock 的区别

1：均是可重入锁

2：synchronized是JVM锁（监视器锁），依赖于JVM；ReentrantLock是轻量级锁，依赖API

3：ReentrantLock实现了一些高级特性：

synchronized是非公平锁，ReentrantLock可以指定公平锁还是非公平锁。

ReentrantLock提供了一种能够中断等待锁的线程的机制。

ReentrantLock类结合Condition实例可以实现“选择性通知”

两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

synchronized 是依赖于 JVM 实现的，前面我们也讲到了虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

ReentrantLock增加了一些高级功能

ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的。默认是非公平锁。
synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知” ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法只会唤醒注册在该Condition实例中的所有等待线程。

基于AQS框架的ReentrantLock（独享、可重入锁），会在后续更新中再详细说明，坚持在总结、构建自己的知识树体系，每天也坚持更新博客，希望看见不一样的自己！各位爱技术看官老爷，欢迎点赞评论，指出文章的不足之处！愿与诸君共勉之！