毫无感情的dj

基于《狂神说Java》JUC并发编程--学习笔记

前言：

本笔记仅做学习与复习使用，不存在刻意抄袭。

------------------------------------------------------------------------------------------------------------

给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!

点击跳转至遇见狂神说哔哩哔哩首页

如果你也是狂神的小迷弟，可以加我好友一起探讨学习。

JUC简述

JUC是什么？

JUC就是java.util.concurrent包，俗称java并发包，是Java开发工程师学习并发的时候需要掌握的内容。

为什么要学习JUC？

我认为起码有以下几点：

一个初级java程序员进阶学习的必经之路；
让我们深刻了解并发的思想，为以后的微服务，分布式打好基础；
能在脑海中构建一个计算机底层处理问题的大概模型，这对研究算法是很有帮助的；
最后一点，也是最现实的一点，这是面试高频考点，学习JUC并发编程，除了能丰富知识，还能提高今后面对面试的底气。

接下来就是《狂神说Java》JUC并发编程的课程笔记和我自己的总结了，或许，没有看视频的学友看着会觉得有些混乱或者逻辑错误。这里还是强调一点，各位最好是配合视频学习，笔记只当作初学或者今后复习就好。

一、学习方式

源码+官方文档（面试高频）

这里简述一下juc在jdk帮助文档的位置（jdk帮助文档请自行百度下载）：

我们打开jdk帮助文档

点击左侧目录：

二、回忆多线程的学习内容

2.1、实现多线程的三种方式

继承Thread类（其实Thread类根本上也实现了Runnable接口）

我们按住ctrl加鼠标左键，点击Thread ：

跳转到：

可以看到其实现了Runnable接口。

这里简单写个小例子回忆一下继承Thread类如何使用。

package com.example.demo1.demo02;
/**
 * @author liar
 */
public class TestThread {
    public static void main(String[] args) {
        Eat eat = new Eat();
        Out out = new Out();
        eat.start();
        out.start();
    }
}
class Eat extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println( "我在吃饭呢");
        }
    }
}
class Out extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("我在拉屎呢");
        }
    }
}

其核心是重写run方法；其运行结果是：

实现Runnable接口

package com.example.demo1.demo02;

/**
 * @author liar
 */
public class TestRunnable {
    public static void main(String[] args) {
        Who who = new Who();
        FBI fbi = new FBI();
        Thread who1 = new Thread(who,"who");
        Thread fbi1 = new Thread(fbi,"FBI");
        who1.start();
        fbi1.start();
    }
}
class Who implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("Who are you ?");
        }
    }
}
class FBI implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("Open the door!!!FBI!!!");
        }
    }
}

运行结果也如预期。

实现Callable接口

package com.example.demo1.demo02;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestCallable {
    public static void main(String[] args) {
        Hit hit = new Hit();
        Connection connection = new Connection();
        FutureTask futureTask1 = new FutureTask(hit);
        FutureTask futureTask2 = new FutureTask(connection);
        Thread t1 = new Thread(futureTask1);
        Thread t2 = new Thread(futureTask2);
        t1.start();
        t2.start();
        try {
            //get()方法的返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object o1 = futureTask1.get();
            Object o2 = futureTask2.get();
            System.out.println(o1);
            System.out.println(o2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class Hit implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 500; i++) {
            System.out.println("怎么样！！你打我啊！！！");
        }
        return "hit";
    }
}
class Connection implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 500; i++) {
            System.out.println("小伙子，出来混，是要讲人脉的！！！");
        }
        return "connection";
    }
}

其运行结果：

其与前两者的区别是，可以通过FutureTask获取返回值的。

2.2、总结

普通的线程代码：继承Thread类

Runnable接口：没有返回值，效率相比于Callable接口较低

2.3、线程和进程

关于线程和进程，如果不能用一句话说出来，说明你掌握的还不够扎实！

进程：

一个正在执行的程序
例如：QQ.exe；是运行程序的集合
一个进程可以包含多个线程且至少包含一个线程

Java真的能开启线程吗？

不能开启线程
分析Thread类的原码了解，最后该类还是调用了本地方法（native）
Java的底层是c++

2.4、并发和并行

并发：（多线程操作同一资源）

CPU一核，模拟出来多线程；天下武功唯快不破，快速交替

并行：（多个人同时走路）

CPU多核，多个线程同时执行

并发编程的本质：充分利用CPU的资源

2.5、线程有几个状态

public enum State {
  NEW,//新生

  RUNNABLE,//运行

  BLOCKED,//阻塞

  WAITING,//等待，一直等待

  TIMED_WAITING,//超时等待，过期不候

  TERMINATED;//终止
}

2.6、wait和sleep的区别

来自不同的类：

wait==>Object
sleep==>Thread

关于锁的释放

wait：会释放锁
sleep：“抱着锁睡觉，不会释放锁”

使用的范围是不同的

wait：必须在同步代码块中使用
sleep：任何地方

是否需要捕获异常

wait：不需要捕获异常（什么叫中断异常？）
sleep：需要捕获异常（存在超时等待的情况）

三、Lock锁（重点）

3.1、回忆"synchronized"

作用：

保证线程安全，例如当多个线程访问统一资源时，会发生数据紊乱问题；

怎么理解：

队列+锁

实例：没有synchronized修饰的方法

package com.example.demo1.demo02;
/**
 * @author liar
 */
public class UnsafeTicket {
    public static void main(String[] args) {
        BuyTicket ticket = new BuyTicket();
        new Thread(ticket,"倒霉的我").start();
        new Thread(ticket,"幸运的你们").start();
        new Thread(ticket,"可恶的黄牛党").start();
    }
}
class BuyTicket implements Runnable{
    private int tickets = 10;
    private boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buy();
        }
    }
    //在方法名前加上"synchronized",那么该方法就变成了同步方法了
    //！！！锁的是"this"！！！
    //'synchronized'默认锁的是this
    private synchronized void buy(){
        if (tickets<=0){
            flag=false;
            //这个return放在这里，如果符合if条件，那么返回出去，不执行下面的sout语句
            return;
        }
        System.out.println(Thread.currentThread().getName()+"买到了第"+tickets--+"张票");
    }
}

我们看一下运行效果：

实例：有synchronized修饰的方法

package com.example.demo1.demo02;
/**
 * @author liar
 */
public class UnsafeTicket {
    public static void main(String[] args) {
        BuyTicket ticket = new BuyTicket();
        new Thread(ticket,"倒霉的我").start();
        new Thread(ticket,"幸运的你们").start();
        new Thread(ticket,"可恶的黄牛党").start();
    }
}
class BuyTicket implements Runnable{
    private int tickets = 10;
    private boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buy();
        }
    }
    //在方法名前加上"synchronized",那么该方法就变成了同步方法了
    //！！！锁的是"this"！！！
    //'synchronized'默认锁的是this
    private synchronized void buy(){
        if (tickets<=0){
            flag=false;
            //这个return放在这里，如果符合if条件，那么返回出去，不执行下面的sout语句
            return;
        }
        System.out.println(Thread.currentThread().getName()+"买到了第"+tickets--+"张票");
    }
}

这下，就是线程安全的了。

3.2、Lock接口（Lock锁）

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//基本的卖票例子
/*
    真正的多线程开发，公司中的开发，降低耦合性
    线程就是一个单独的资源类，没有任何附属操作
    1、属性、方法
 */
public class SaleTicketDemo2 {
    public static void main(String[] args) {
        //并发：多线程操作同一个类,把资源类丢入线程
        Ticket2 ticket = new Ticket2();
        //@FunctionalInterface 函数式接口,jdk1.8 lambda表达式 (参数)->{代码}
        new Thread( () ->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread( () ->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread( () ->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();

    }
}

//Lock三部曲
//1.new ReentrantLock();
//2. lock.lock();    加锁
//3.finally -->  lock.unlock(); 解锁
class Ticket2{
    //属性方法
    private int number = 50;
    Lock lock = new ReentrantLock();

    public  void sale(){
        lock.lock();    //加锁

        try{
            //业务代码
            if(number > 0){
                System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余" + number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //解锁
            lock.unlock();
        }

    }
}

3.3、Synchronized和Lock的区别

1、Synchronized内置的Java关键字，Lock是一个Java类
2、Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
3、Synchronized是全自动的，会自动释放锁，Lock必须要手动释放锁，如果不释放锁，死锁
4、Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去
5、Synchronized可重入锁，不可以中断，非公平；Lock可重入锁，可以判断锁，非公平（可以自己设置）
6、Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码

3.5、思考

锁是什么？如何判断锁的是谁？

四、生产者和消费者问题

面试：单例模式、排序算法、生产者和消费者问题、死锁

4.1、synchronized版

package com.my.pc;
/*
* 线程之间的通信问题：生产者和消费者问题（等待唤醒，通知唤醒）
*
* 线程交替执行：
*   生产者和消费者操作同一个变量
*       生产者：+1
*       消费者：-1
* */
public class Test {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"生产者").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者").start();
    }
}

//资源类
/*
* 编写资源类的思路：
*   判断等待、业务、通知
* */
class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        if (number!=0){
            //生产者等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //唤醒消费者进程进行“消费”
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        if (number==0){
            //消费者等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //唤醒生产者进程进行“生产”
        this.notifyAll();
    }

}

这样会出现问题！！–虚假唤醒

场景：当出现多个生产者和消费者时，会出现数据紊乱？

原因：就是这个if语句只判断一次：当消费者线程阻塞，来唤醒生产者线程时，多个生产者线程都会被唤醒，但是只有第二个生产者线程执行了if判断，然后第二个生产者线程阻塞（基于if语句的机理），因为第一个生产者线程能够正常执行，而剩余的其他生产者线程，则会执行if语句后面的方法（“意思就是后面的生产者线程在if判断前面生产者线程时，利用了if语句的bug捡了漏”）

（1）if判断流水线状态为空时，线程被阻塞，这时if判断就完成了，线程被唤醒后直接执行线程剩余操作

（2）while判断流水线状态为空时，线程被阻塞，这时的while循环没有完成，线程被唤醒后会先进行while判断

解决方法：

把if语句改为while语句

package com.my.pc;
/*
* 线程之间的通信问题：生产者和消费者问题（等待唤醒，通知唤醒）
*
* 线程交替执行：
*   生产者和消费者操作同一个变量
*       生产者：+1
*       消费者：-1
* */
public class Test {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"生产者").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"D").start();
    }
}

//资源类
/*
* 编写资源类的思路：
*   判断等待、业务、通知
* */
class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
/*        if (number!=0){
            //生产者等待
            this.wait();
        }*/
        while(number!=0){
            //生产者等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //唤醒消费者进程进行“消费”
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        /*if (number==0){
            //消费者等待
            this.wait();
        }*/
        while (number==0){
            //消费者等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //唤醒生产者进程进行“生产”
        this.notifyAll();
    }

}

4.2、JUC版

package com.my.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 线程之间的通信问题：生产者和消费者问题（等待唤醒，通知唤醒）
 *
 * 线程交替执行：
 *   生产者和消费者操作同一个变量
 *       生产者：+1
 *       消费者：-1
 * */
public class Test01 {
    public static void main(String[] args) {
        Data01 data = new Data01();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"生产者").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"D").start();
    }
}

//资源类
/*
 * 编写资源类的思路：
 *   判断等待、业务、通知
 * */
class Data01{
    private int number = 0;

    Lock lock = new ReentrantLock();

    Condition condition = lock.newCondition();

    public synchronized void increment() throws InterruptedException {
        //加锁
        lock.lock();
        try {
            //业务代码
            while (number!=0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //唤醒消费者进程进行“消费”
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }
    }

    public synchronized void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number==0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //唤醒生产者进程进行“生产”
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }
    }
}

4.3、思考

Condition绝不仅仅只是覆盖原来的wait和notify，它肯定还有别的优势

–Condition实现精准通知唤醒

package com.my.pc;
/*
* 该例来了解Condition的优势和好处
* */

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//让线程按照顺序执行，先执行线程A，再执行线程B，最后执行线程C，之后再从头执行线程A
public class Test02 {
    public static void main(String[] args) {
        Data02 data02 = new Data02();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data02.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data02.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data02.printC();
            }
        },"C").start();
    }
}

class Data02{
    private Lock lock = new ReentrantLock();

    //监视器
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int number = 1;

    public void printA(){
        lock.lock();

        try {
            //业务代码
            while (number!=1){
                condition1.await();
            }
            number=2;
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAAA");

            //唤醒进程，唤醒指定的进程
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void printB(){
        lock.lock();

        try {
            //业务代码
            while (number!=2){
                condition2.await();
            }
            number=3;
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBBB");

            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();

        try {
            //业务代码
            while (number!=3){
                condition3.await();
            }
            number=1;
            System.out.println(Thread.currentThread().getName()+"=>CCCCCCCC");

            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

之前锁在对象，之后锁在lock

五、8锁现象彻底理解锁

5.1、8锁现象

其实就是关于锁的八个问题；通过8锁现象，来深入理解锁。

标准情况下，是先打印“发短信”还是“打电话”–（发短息打电话）

普通同步方法（被synchronized关键字）“锁”的是方法调用者–phone对象（变量名）
同一个资源类中所有方法共用一把“锁”
所有线程被顺序创建，也就顺序打印
2、sendMessage延迟4秒，是先打印“发短信”还是“打电话”–（发短息打电话）

给第一个sendMessage方法延迟四秒
那么会出现一种状况：一秒后，在A线程还在等待“休眠”结束时，B线程开启，之后线程A和B开始竞争资源，但是因为A线程还在休眠，所以B线程直接获取到资源，先进行打印

package com.my.lock8;

import java.util.concurrent.TimeUnit;

/*
* 8锁现象：其实就是8个关于锁的问题
*   1、标准情况下，是先打印“发短信”还是“打电话”--（发短息  打电话）
*   2、sendMessage延迟4秒，是先打印“发短信”还是“打电话”--（发短息  打电话）
*   上述出现两种情况的原因：synchronized;
* */
public class Test01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class Phone{
    //synchronized：锁的对象是方法调用者--phone对象
    //两个方法共用同一把锁，谁先拿到谁执行
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

3、较之前资源类中新增一个普通方法hello，让线程B去执行，那么输出结果是先打印“Hello”还是“发短信”–（Hello 发短信）

hello是一个普通方法，给这个方法没有加锁
线程A要执行的方法中需要休眠4秒
但是hello方法没有加锁，更不可能和其他方法共用一把锁
因此，在休眠1秒后，B线程直接执行，之后等休眠4秒后A线程才执行
4、新建俩个资源类对象，第一个对象调用发短信方法，第二个调用打电话方法，那么输出结果是先打印“发短信”还是“打电话”–（打电话发短信）

普通同步方法（被synchronized）它锁的对象是“方法调用者”–phone对象（变量名）
所有一个“方法调用者”就是一把“锁”
这里相当于有两把“锁”
那么两个AB线程可以随机执行，但是因为A线程的方法要休眠4秒，所有B线程先执行完毕

package com.my.lock8;

import java.util.concurrent.TimeUnit;

/*
 * 8锁现象：其实就是8个关于锁的问题
 *   3、较之前资源类中新增一个普通方法hello，让线程B去执行，那么输出结果是先打印“Hello”还是“发短信”--（Hello  发短信）
 *   4、新建俩个资源类对象，第一个对象调用发短信方法，第二个调用打电话方法，那么输出结果是先打印“发短信”还是“打电话”--（打电话  发短信）
 * */
public class Test02 {
    public static void main(String[] args) {
        //实例化两个对象
        synchronized：锁的对象是方法调用者--phone对象，因此两个对象就是两把锁！！
        Phone02 phone1 = new Phone02();
        Phone02 phone2 = new Phone02();

        new Thread(()->{
            phone1.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone02{
    //synchronized：锁的对象是方法调用者--phone对象
    //两个方法共用同一把锁，谁先拿到谁执行
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    //普通方法：不是同步方法，不受锁的限制
    public void hello(){
        System.out.println("Hello");
    }
}

5、将资源类中的两个方法修改为静态方法，创建一个资源类对象，调用两个方法，判断先打印“发短信”还是“打电话”–（发短信打电话）

静态同步方法（被static修饰的普通同步方法）
资源类中的所有静态同步方法“锁”的是该资源类（Phone）的类模板（Class模板）
因此，还是按照创建线程的的顺序执行（A线程执行完后，释放锁；B线程拿到锁执行）
6、创建两个资源类对象，两个静态同步方法，调用两个方法，判断先打印“发短信”还是“打电话”–（发短信打电话）

不要被误导：因为静态同步方法锁的是Class类模板，而不是普通同步方法的方法调用者phone对象（变量名）
所有还是按照线程的创建顺序执行

package com.my.lock8;

import java.util.concurrent.TimeUnit;

/*
 * 8锁现象：其实就是8个关于锁的问题
 *   5、将资源类中的两个方法修改为静态方法，创建一个资源类对象，调用两个方法，判断先打印“发短信”还是“打电话”--（发短信  打电话）
 *   6、创建两个资源类对象，两个静态同步方法，调用两个方法，判断先打印“发短信”还是“打电话”--（打电话  发短信）
 * */
public class Test03 {
    public static void main(String[] args) {
        //两个资源类对象共用一个Class模板，而且synchronized锁的是Class模板
        Phone03 phone1 = new Phone03();
        Phone03 phone2 = new Phone03();

        new Thread(()->{
            phone1.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone03{
    //synchronized：锁的对象是Class模板
    //static 静态方法
    //类一旦被加载就有了，Class模板，一个类有且仅有一个唯一的Class模板
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }
}

7、将两个方法一个设置为静态方法，一个设置为普通同步方法，创建一个资源类对象，执行两个方法，先打印“发短信”还是“打电话”（打电话发短信）

静态同步方法锁的是Class类模板，普通同步方法锁的是方法调用者；因此在这里也相当于两把“锁”，线程之间互不干扰
线程A的休眠时间长，因此先执行了B线程
8、创建两个资源类对象，调用下面的两个方法，先打印“发短信”还是“打电话”（打电话发短信）

两把“锁”
A线程与B线程执行之间互不打扰

package com.my.lock8;

import java.util.concurrent.TimeUnit;

/*
 * 8锁现象：其实就是8个关于锁的问题
 *   7、将两个方法一个设置为静态方法，一个设置为普通同步方法，创建一个资源类对象，执行两个方法，先打印“发短信”还是“打电话”（打电话  发短信）
 *   8、创建两个资源类对象，调用下面的两个方法，先打印“发短信”还是“打电话”（打电话  发短信）
 * */
public class Test04 {
    public static void main(String[] args) {
        Phone04 phone1 = new Phone04();
        Phone04 phone2 = new Phone04();

        new Thread(()->{
            phone1.sendMessage();
        },"A").start();

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

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone04{
    //静态的同步方法：锁的是Class模板
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //普通的同步方法：锁的是方法调用者
    public synchronized void call(){
        System.out.println("打电话");
    }
}

5.2、总结

明白synchronized修饰的普通同步方法和加上static关键字的静态同步方法的区别
普通方法和同步方法的区别

六、集合类不安全

6.1、List结合不安全

package com.my.list;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

//集合是不安全的

//java.util.ConcurrentModificationException：并发修改异常
public class ListTest {
    public static void main(String[] args) {
        /*
        * 并发线程下，ArrayList集合不安全，怎么解决？
        *   1、使用List接口的古老实现类：Vector--List list = new Vector<>();
        *   2、使用Collections工具类:List