引用了

Lock与synchronized 的区别

详解synchronized与Lock的区别与使用

Java并发编程：volatile关键字解析

volatile

['vɒlətaɪl] 易变化的

synchronized

['sɪŋkrənaɪzd] 同步的

reentrant (lock)

[ri:'entrənt] 可重入

为什么要有锁

①cpu处理以线程为单位，cpu又有一块硬件叫cache(快速缓存区),每个线程对应了自己的一块快速缓存区。因为cpu的处理速度很快，内存处理速度太慢了，所以中间有一块缓存区，我们熟悉的cache,经常听到的几级缓存。

②假设现在是单核cpu，所有的线程看起来并行，其实是串行。只是不停地在线程之间切换。

③现在两个线程执行a++,a=10。如果线程1读入a，cpu切换到了线程2，线程2读入a,结果a=11,本来应该是a=12。

④所以我们要保护值，保持值是新鲜的。于是我们使用了volatile。单线程成功了。线程1执行了a++，数据马上会被写入内存，并要求线程2重新读取a的值。我们成功了，好像不需要锁了。

⑤回到常用的多核cpu,线程1与线程2真正的同时执行了，两个核心同一时刻执行，更新变量来不及了。

⑥所以又想出了另外的一个办法，那就只能去管理过程了，这那些危险操作一个一个执行，所以到了锁。

很推荐这个----Java并发编程：volatile关键字解析

区别

√----保证 ×----不保证

3个属性更好的解释请到这里----Java并发编程：volatile关键字解析

属性	Synchronized	lock	volatile	解释
可见性	√	√	√	变量被操作之后，能够快速写入内存，并提醒其他线程重读，加锁是通过一个一个执行保证了可见性。
原子性	√	√	×	做的过程中，不要有相关的来打扰，不相关的我们也不关心，加锁是通过一个一个执行保证了流程不会被相关的打扰。
有序性	√	√	√	在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

很明显如果我们满足了原子性，我们就可以只使用volatile

使用场景

Volatile

通常来说，使用volatile必须具备以下2个条件：
1）对变量的写操作不依赖于当前值
2）该变量没有包含在具有其他变量的不变式中
实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。
事实上，我的理解就是上面的2个条件需要保证操作是原子性操作，才能保证使用volatile关键字的程序在并发时能够正确执行。
(转自Java并发编程：volatile关键字解析)

public class Main {

    public static volatile int a;
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i < 10; i++){
            int finalI = i;
            new Thread(){
                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        a = finalI * j;
                    }
                }
            }.start();
        }

        for (int i = 0; i < 100; i++){
            System.out.println(a);
        }
    }
}

Synchronized(线程少的时候效率更高)----2线程 1000000次增加

public class Main{
    public volatile int inc = 0;

    public synchronized void increase() {
        inc++;
    }

    public static void main(String[] args) throws InterruptedException {
        final Main test = new Main();
        long a = System.currentTimeMillis();
        for(int i=0;i<2;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000000;j++) {
                        test.increase();
                    }
                    System.out.println(System.currentTimeMillis() - a + "ms");
                }
            }.start();
        }

        Thread.sleep(1000);
        System.out.println(test.inc);
    }
}

输出：65ms 2000000

public class Main{
    public volatile int inc = 0;

    public ReentrantLock lock = new ReentrantLock();
    public void increase() {
        lock.lock();
        inc++;
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        final Main test = new Main();
        long a = System.currentTimeMillis();
        for(int i=0;i<2;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000000;j++) {
                        test.increase();
                    }
                    System.out.println(System.currentTimeMillis() - a + "ms");
                }
            }.start();
        }

        Thread.sleep(1000);
        System.out.println(test.inc);
    }
}

输出:100ms 2000000

ReentrantLock(线程多的时候效率更高)----200线程 10000次增加

public class Main{
    public volatile int inc = 0;

    public ReentrantLock lock = new ReentrantLock();
    public void increase() {
        lock.lock();
        inc++;
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        final Main test = new Main();
        long a = System.currentTimeMillis();
        for(int i=0;i<200;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<10000;j++) {
                        test.increase();
                    }
                    System.out.println(System.currentTimeMillis() - a + "ms");
                }
            }.start();
        }

        Thread.sleep(1000);
        System.out.println(test.inc);
    }
}

输出：91ms 2000000

public class Main{
    public volatile int inc = 0;

    public synchronized void increase() {
        inc++;
    }

    public static void main(String[] args) throws InterruptedException {
        final Main test = new Main();
        long a = System.currentTimeMillis();
        for(int i=0;i<200;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<10000;j++) {
                        test.increase();
                    }
                    System.out.println(System.currentTimeMillis() - a + "ms");
                }
            }.start();
        }

        Thread.sleep(1000);
        System.out.println(test.inc);
    }
}

输出：196ms 2000000

比较

类别	synchronized	Lock
存在层次	Java的关键字，在jvm层面上	是一个类
锁的释放	1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁	在finally中必须释放锁，不然容易造成线程死锁
锁的获取	假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待	分情况而定，Lock有多个锁获取的方式，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待
锁状态	无法判断	可以判断
锁类型	可重入 不可中断 非公平	可重入 可判断 可公平（两者皆可）
性能	少量同步	大量同步

回到为什么线程少的时候Synchronized快，多的时候慢

引用了：https://blog.csdn.net/ganyao939543405/article/details/52486316

A).一般认为synchronized关键字的实现是源自于像信号量之类的线程同步机制，涉及到线程运行状态的切换，在高并发状态下，CPU消耗过多的时间在线程的调度上，从而造成了性能的极大浪费。
B).lock实现原理则是依赖于硬件，现代处理器都支持CAS指令，所谓CAS指令简单的来说Compare And Set，CPU循环执行指令直到得到所期望的结果，换句话来说就是当变量真实值不等于当前线程调用时的值的时候(说明其他线程已经将这个值改变)，就不会赋予变量新的值。这样就保证了变量在多线程环境下的安全性。

当JDK版本高于1.6的时候，synchronized已经被做了CAS的优化：具体是这样的，当执行到synchronized代码块时，先对对象头的锁标志位用lock cmpxchg的方式设置成“锁住“状态，释放锁时，在用lock cmpxchg的方式修改对象头的锁标志位为”释放“状态，写操作都立刻写回主内存。JVM会进一步对synchronized时CAS失败的那些线程进行阻塞操作(调用操作系统的信号量)(此段来摘自别处)。也就是先CAS操作，不行的话继而阻塞线程。

除此之外，系统环境，CPU架构，虚拟机环境都会影响两者的性能关系。