多线程与高并发（一）--线程的基础概念

一、什么是线程？

一个程序里不同的执行路径就是一个线程，是进程里面最小的执行单元。

例子：

public class test {

    private static class T1 extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MICROSECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("T1");
            }
        }
    }


    public static void main(String[] args) {
        //new T1().run();
        new T1().start();
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.MICROSECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main");
        }
    }
}

new T1().run()时输出：

T1
T1
T1
T1
T1
T1
T1
T1
T1
T1
main
main
main
main
main
main
main
main
main main

new T1().start()时输出：

main
T1
main
T1
main
T1
main
T1
main
T1
T1
main
main
T1
T1
main
T1
main
T1 main

二、run() 和start()的区别?

调run()方法时候只有一条执行路径，调start(）时候是run方法和mian方法同时进行是两条执行路径。

三、什么是进程？

做一个简单的解释，你的硬盘上有一个简单的程序，这个程序叫QQ.exe，这是一个程序，这个程序是一个静态的概念，它被扔在硬盘上也没人理他，但是当你双击它，弹出一个界面输入账号密码登录进去了，OK，这个时候叫做一个进程。进程相对于程序来说它是一个动态的概念

四、线程的创建方式有几种？

第一种，通过继承Thread类创建线程类

   static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Hello MyThread!");
        }
    }

第二种，通过实现Runnable接口创建线程类

  static class MyRun implements Runnable {
        @Override
        public void run() {
            System.out.println("Hello MyRun!");
        }
    }

第三种，通过Callable和Future接口创建线程

    static class MyCall implements Callable<String> {
        @Override
        public String call() {
            System.out.println("Hello MyCall");
            return "success";
        }
    }

五、启动线程的5种方式

    public static void main(String[] args) {
        //--1
        new MyThread().start();

        //--2
        new Thread(new MyRun()).start();

        //--3
        new Thread(() -> {
            System.out.println("Hello Lambda!");
        }).start();

        //--4
        Thread t = new Thread(new FutureTask<String>(new MyCall()));
        t.start();

        //--5
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(() -> {
            System.out.println("Hello ThreadPool");
        });
        service.shutdown();
    }

输出

Hello MyRun!
Hello MyThread!
Hello ThreadPool
Hello Lambda! Hello MyCall

六、线程的几种常见方法？

sleep

Sleep,意思就是睡眠，当前线程暂停一段时间让给别的线程去运行。Sleep是怎么复活的？由你的睡眠时间而定，等睡眠到规定的时间自动复活。

一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。

    static void testSleep() {
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println("A" + i);
                try {

                    Thread.sleep(5000);
                    //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    static void testSleep2() {
        new Thread(() -> {
            for (int i = 0; i < 2; i++) {
                System.out.println("B" + i);
            }
        }).start();
    }

输出

A0
B0
B1
A1 A2

yield

就是当前线程正在执行的时候停止下来进入等待队列，回到等待队列里在系统的调度算法里头,还是依然有可能把你刚回去的这个线程拿回来继续执行，当然，更大的可能性是把原来等待的那些拿出一个来执行，所以yield的意思是我让出一下CPU，后面你们能不能抢到那我不管。

一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。

  static void testYield() {
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("A" + i);
                if (i % 10 == 0) Thread.yield();
            }
        }).start();
        
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("------------B" + i);
                if (i % 10 == 0) Thread.yield();
            }
        }).start();
    }

join/thread.join(long millis)

意思就是在自己当前线程加入你调用Join的线程，本线程等待。等调用的线程运行完了，自己再去执行。t1和t2两个线程，在t1的某个点上调用了t2.join,它会跑到t2去运行，t1等待t2运行完毕继续t1运行（自己join自己没有意义）。

当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入RUNNABLE状态，也有可能进入BLOCKED状态（因为join是基于wait实现的）。

    static void testJoin() {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("T1 " + i);
                try {
                    Thread.sleep(500); //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                t1.join();
            } catch (Exception e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("T2 " + i);
                try {
                    Thread.sleep(500); //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
    }

输出

T1 0
T1 1
T1 2
T1 3
T1 4
T2 0
T2 1
T2 2
T2 3 T2 4

obj.wait()

当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。

obj.notify()

唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。

LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines)

当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，需要通过LockSupport.unpark(Thread thread)唤醒。

七、线程的状态有几种？

新建状态

当我们new一个线程时，还没有调用start()该线程处于新建状态

Ready就绪状态/Running运行状态

线程对象调用 start（）方法时候，他会被线程调度器来执行，也就是交给操作系统来执行了，那么操作系统来执行的时候，这整个的状态叫Runnable，Runnable内部有两个状态(1)Ready就绪状态/(2)Running运行状态。就绪状态是说扔到CPU的等待队列里面去排队等待CPU运行，等真正扔到 CPU上去运行的时候才叫Running运行状态。（调用yiled时候会从Running状态跑到Ready状态去，线程配调度器选中执行的时候又从Ready状态跑到Running状态去）

Teminated结束状态

线程顺利的执行完了就会进去Teminated结束状态，（需要注意Teminated完了之后还可不可以回到new状态再调用start？这是不行的，完了这就是结束了）

Blocked阻塞状态

在同步代码块的情况就下没得到锁就会阻塞状态，获得锁的时候是就绪状态运行。

Waiting等待状态

在运行的时候如果调用了o.wait()、t.join()、LockSupport.park()进入Waiting状态，调用o.notify()、o.notifiAll()、LockSupport.unpark()就又回到Running状态。

TimedWaiting等待状态

TimedWaiting按照时间等待，等时间结束自己就回去了，Thread.sleep(time)、o.wait(time)、t.jion(time)、LockSupport.parkNanos()、LockSupport.parkUntil()这些都是关于时间等待的方法。

问题1：哪些是JVM管理的？哪些是操作系统管理的？

上面这些状态全是由JVM管理的，因为JVM管理的时候也要通过操作系统，所以呢，那个是操作系统和那个是JVM他俩分不开，JVM是跑在操作系统上的一个普通程序

问题2：线程什么状态时候会被挂起？挂起是否也是一个状态？

Running的时候，在一个cpu上会跑很多个线程，cpu会隔一段时间执行这个线程一下，在隔一段时间执行那个线程一下，这个是cpu内部的一个调度，把这个状态线程扔出去，从running扔回去就叫线程被挂起，cpu控制它。

问题3：怎么样得到这个线程的状态呢？

通过getState()这个方法获取

八、关闭线程的正确方式

让线程正常结束，不建议使用stop()方法。

问题1. stop() 和 suspend() 方法为何不推荐使用？

反对使用 stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。
suspend() 方法容易发生死锁。调用 suspend() 的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被 “挂起” 的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用 suspend()，而应在自己的 Thread 类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait() 命其进入等待状态。若标志指出线程应当恢复，则用一个 notify() 重新启动线程。

九、synchronized关键字

1.锁可以锁任意对象

这里的锁作用于O对象

public class test {

    private int count = 10;
    private Object o = new Object();

    public void m() {
        synchronized (o) { //任何线程要想执行下面的代码，必须先拿到o的锁
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }

    public static void main(String[] args) {
        new test().m();
    }
}

2.锁可以锁定当前对象

通过synchronized(this)

public class test {

    private int count = 10;

    public void m() {
        synchronized (this) { //任何线程想要执行那个下面的代码，必须先要拿到this的锁
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }

    public static void main(String[] args) {
        new test().m();
    }
}

如果你要是锁定当前对象呢，你也可以写成如下方法。synchronized方法和synchronized(this)执行这段代码它是等值的


public class test {

    private int count = 10;

    public synchronized void m() { //等同于在方法的代码执行时要synchronized(this)
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

    public static void main(String[] args) {
        new test().m();
    }
}

3.锁可以作用于静态方法

我们知道静态方法static是没有this对象的，你不需要new出一个对象来就能执行这个方法，但如果这个方法上面加一个synchronized的话就代表synchronized(test.class)。这里这个synchronized(test.class)锁的就是test类的对象

public class test {
    
    private static int count = 10;
    public synchronized static void m() {//这里等同于synchronized(T.class)
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

    public static void mm() {
        synchronized (test.class) { 
            count--;
        }
    }
}

问题：test.class是单例的吗？

一个class load到内存它是不是单例的，想想看。一般情况下是，如果是在同一个ClassLoader空间那它一定是。不是同一个类加载器就不是了，不同的类加载器互相之间也不能访问。所以说你能访问它，那他一定就是单例。

练习

如果有一个线程把它从10减到9了，然后又有一个线程在前面一个线程还没有输出呢进来了把9又减到了8，继续输出的8，而不是9。如果你想修正它，可以第一个是在上面加volatile，还可以synchronized，加了synchronized就没有必要在加volatile了，因为synchronized既保证了原子性，又保证了可见性。


public class test implements Runnable{

    private /*volatile*/ int count = 100;

    @Override
    public /*synchronized*/ void run() {
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

    public static void main(String[] args) {
        test t = new test();
        for (int i = 0; i < 10; i++) {
            new Thread(t, "THREAD" + i).start();
        }
    }
}

输出

THREAD0 count = 98
THREAD5 count = 97
THREAD2 count = 98
THREAD4 count = 95
THREAD9 count = 96
THREAD8 count = 94
THREAD6 count = 93
THREAD1 count = 92
THREAD3 count = 91

4. 同步方法和非同步方法是否可以同时调用

可以

列子

比如说：张三，给他设置100块钱启动了，睡了1毫秒之后去读它的值，然后再睡2秒再去读它的值这个时候你会看到读到的值有问题，原因是在设定的过程中this.name你中间睡了一下，这个过程当中我模拟了一个线程来读，这个时候调用的是getBalance方法，而调用这个方法的时候是不用加锁的，所以说我不需要等你整个过程执行完就可以读到你中间结果产生的内存，这个现象就叫做脏读。这问题的产生就是synchronized方法和非synchronized方法是同时运行的。解决就是把getBalance加上 synchronized就可以了，如果你的业务允许脏读，就可以不用加锁，加锁之后的效率低下。

public class test implements Runnable {

    String name;
    double balance;

    public double getBalance() {
        return balance;
    }

    public synchronized void setBalance(String name,double balance) {
        this.name = name;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.balance = balance;
    }

    @Override
    public void run() {

    }

    public static void main(String[] args) {
        test a = new test();
        new Thread(() -> a.setBalance("zhangsan", 100.0)).start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(a.getBalance());

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(a.getBalance());
    }
}

5.可重入

一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁。

如果是一个同步方法调用另外一个同步方法，有一个方法加了锁，另外一个方法也需要加锁，加的是同
一把锁也是同一个线程，那这个时候申请仍然会得到该对象的锁。比如说是synchronized可重入的，有
一个方法m1是synchronized，有一个方法m2也是synchrionzed，m1里能不能调m2。我们m1开始的时
候这个线程得到了这把锁，然后在m1里面调用m2，如果说这个时候不允许任何线程再来拿这把锁的时
候就死锁了。这个时候调m2它发现是同一个线程，因为你m2也需要申请这把锁，它发现是同一个线程申请的这把锁，允许，可以没问题，这就叫可重入锁。

所谓的重入锁就是你拿到这把锁之后不停加锁加锁，加好几道，但锁定的还是同一个对象，去一道就减个1，就是这么个概念。
列子

public class test {

    synchronized void m1() {

        System.out.println("m1 start");

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        m2();
        System.out.println("m1 end");
    }

    synchronized void m2() {

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("m2");
    }

    public static void main(String[] args) {
        new test().m1();
    }
}

输出

m1 start
m2 m1 end

6.异常锁

程序在执行过程中，如果出现异常，默认情况锁会被释放。所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。
比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适，在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。因此要非常小心的处理同步业务逻辑中的异常。
举个栗子

/**
 * 看这个小程序，加了锁synchronized void m()，while(true)不断执行，线程启动，count++ 如果等于5的
 * 时候认为的产生异常。这时候如果产生任何异常，就会出现什么情况呢？ 就会被原来的那些个准备拿到
 * 这把锁的程序乱冲进来，程序乱入。这是异常的概念。
 */
public class test  {

    int count = 0;

    synchronized void m() {

        System.out.println(Thread.currentThread().getName() + " start");

        while (true) {
            count++;
            System.out.println(Thread.currentThread().getName() + " count = " + count);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count == 5) {
                int i = 1 / 0; //此处抛出异常，锁将被释放，要想不被释放，可以在这里进行 catch，然后让循环继续
                System.out.println(i);
            }

        }
    }

    public static void main(String[] args) {

        test t = new test();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                t.m();
            }
        };

        new Thread(r, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(r, "t2").start();
    }
}

输出

t1 start
t1 count = 1
t1 count = 2
t1 count = 3
t1 count = 4
t1 count = 5
t2 start
t2 count = 6
Exception in thread “t1” java.lang.ArithmeticException: / by zero
at com.jiakai.damaiwang.test.m(test.java:31)
at com.jiakai.damaiwang.test$1.run(test.java:44)
at java.lang.Thread.run(Thread.java:748)
t2 count = 7
t2 count = 8
t2 count = 9 t2 count = 10 …

7.synchronized的底层实现

早期，jdk早期的时候，这个synchronized的底层实现是重量级的，重量级到这个synchronized都
是要去找操作系统去申请锁的地步，这就会造成synchronized效率非常低，java后来越来越开始
处理高并发的程序的时候，很多程序员都不满意，说这个synchrionized用的太重了，我没办法，就要开发新的框架，不用你原生的了。
改进，后来的改进才有了锁升级的概念。
锁升级的概念

原来，都要去找操作系统，要找内核去申请这把锁，到后期做了对synchronized的一些改进，他的效率比原来要改变了不少，改进的地方。当我们使用synchronized的时候HotSpot的实现是这样的：上来之后第一个去访问某把锁的线程比如sync (Object) ，来了之后先在这个Object的头上面markword记录这个线程。（如果只有第一个线程访问的时候实际上是没有给这个Object加锁的，在内部实现的时候，只是记录这个线程的ID（偏向锁））。偏向锁如果有线程争用的话，就升级为自旋锁，概念就是（有一个哥们儿在蹲马桶，另外来了一个哥们，他就在旁边儿等着，他不会跑到cpu的就绪队列里去，而就在这等着占用cpu，用一个while的循环在这儿转圈玩儿，很多圈之后不行的话就再一次进行升级）。自旋锁转圈十次之后，升级为重量级锁，重量级锁就是去操作系统那里去申请资源。这是一个锁升级的过程。

需要注意并不是CAS的效率就一定比系统锁要高，这个要区分实际情况

执行时间短（加锁代码），线程数少，用自旋
执行时间长，线程数多，用系统锁

8.synchronized(Object) 不能用String常量 Integer Long

本文使用文章同步助手同步

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 219,869评论 6赞 508
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 93,716评论 3赞 396
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 166,223评论 0赞 357
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 59,047评论 1赞 295
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 68,089评论 6赞 395
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,839评论 1赞 308
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,516评论 3赞 420
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 39,410评论 0赞 276
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,920评论 1赞 319
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 38,052评论 3赞 340
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 40,179评论 1赞 352
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,868评论 5赞 346
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,522评论 3赞 331
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 32,070评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 33,186评论 1赞 272
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 48,487评论 3赞 375
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 45,162评论 2赞 356

多线程与高并发（一）--线程的基础概念

一、什么是线程？

二、run() 和start()的区别?

三、什么是进程？

四、线程的创建方式有几种？

五、启动线程的5种方式

六、线程的几种常见方法？

七、线程的状态有几种？

问题1：哪些是JVM管理的？哪些是操作系统管理的？

问题2：线程什么状态时候会被挂起？挂起是否也是一个状态？

问题3：怎么样得到这个线程的状态呢？

八、关闭线程的正确方式

问题1. stop() 和 suspend() 方法为何不推荐使用？

九、synchronized关键字

1.锁可以锁任意对象

2.锁可以锁定当前对象

3.锁可以作用于静态方法

问题：test.class是单例的吗？

练习

4. 同步方法和非同步方法是否可以同时调用

5.可重入

6.异常锁

7.synchronized的底层实现

需要注意并不是CAS的效率就一定比系统锁要高，这个要区分实际情况

8.synchronized(Object) 不能用String常量 Integer Long

推荐阅读更多精彩内容