凉水不好喝

【狂神说笔记】JUC并发编程（多线程进阶）

JUC并发编程（多线程进阶）
- 一、学习方式
- 二、回忆多线程
- - 2.1、实现多线程的三种方式
  - 2.2、总结
  - 2.3、线程和进程
  - 2.4、并发和并行
  - 2.5、线程有几个状态
  - 2.6、wait和sleep的区别
  - 2.7、匿名内部类
  - 2.8、Lambda表达式
  - 2.9、什么叫OOP编程？
- 三、Lock锁（重点）
- - 3.1、回忆"synchronized"
  - 3.2、Lock接口（Lock锁）
  - 3.3、Lock锁的使用
  - 3.4、synchronized 和 Lock 的区别
  - - 3.5、思考
- 四、生产者和消费者问题
- - 4.1、synchronized版
  - 4.2、JUC版
  - 4.3、思考
- 五、8锁现象彻底理解锁
- - 5.1、8锁现象
  - 5.2、总结
- 六、集合类不安全
- - 6.1、List结合不安全
  - 6.2、Set集合不安全
  - 6.3、Map集合不安全
- 七、走进Callable
- 八、常用的辅助类
- - 8.1、CountDownLatch（“减法计数器”）
  - 8.2、CyclicBarrier（“加法计数器”）
  - 8.3、Semaphore（“信号量”）
- 九、读写锁（ReentrantReadWriteLock）
- 十、阻塞队列
- - 10.1、同步队列（SynchronizedQueue）
- 十一、线程池（重点）
- - 11.1、池化技术
  - 11.2、线程池的好处
  - 11.3、线程池
  - - 1、三大方法
    - 2、七大参数和四大策略
    - 3、核心线程池最大数量到底定义到多少？
- 十二、四大函数式接口（必须掌握）
- - 12.1、函数式接口
  - 12.2、详解
  - - 1、Function（函数型接口）
    - 2、Predicate（断定型接口）
    - 3、Consumer（消费型接口）
    - 4、Supplier（供给型接口）
- 十三、Stream流式计算
- - 13.1、什么是Stream流式计算
  - 13.2.具体示例
- 十四、ForkJoin
- - 14.1、什么是ForkJoin（分支合并）
  - 14.2、ForkJoin特点
  - 14.3、ForkJoin实例
- 十五、异步回调
- 十六、JMM
- - 16.1、Volatile关键字
  - 16.2、JMM
  - - 1、关于JMM的一些约定
    - 2、8种操作
- 十七、Volatile
- - 17.1、保证可见性
  - 17.2、不保证原子性
  - 17.3、指令重排
- 十八、单例模式
- - 18.1、单例模式的定义
  - 18.2、饿汉式单例模式
  - 18.3、懒汉式单例模式
  - 18.4、枚举类
- 十九、CAS
- - 19.1、ABA问题
- 二十、原子引用
- 二十一、各种锁的理解
- - 21.1、公平锁和非公平锁
  - 21.2、可重入锁
  - 21.3、自旋锁
  - 21.4、死锁
  - - 怎么排查死锁

JUC并发编程（多线程进阶）

一、学习方式

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

二、回忆多线程

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

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

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：需要捕获异常（存在超时等待的情况）

2.7、匿名内部类

参考链接

2.8、Lambda表达式

参考链接

2.9、什么叫OOP编程？

面向对象编程

三、Lock锁（重点）

3.1、回忆"synchronized"

作用：

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

用法：

用来修饰代码块和方法

怎么理解：

队列+锁

实例：

//不安全的线程
import sun.security.krb5.internal.Ticket;

/*
可以买到负数的票的原因：
    当只剩下一张票时，三个线程都认为是有票；
    因此它们都把“1”拿到自己的内存；
    第一次拿后，对象内存剩余0；
    第二次拿后，对象内存剩余-1；
 */
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锁）

公平锁：十分公平，先来后到（排队）3h 3s

非公平锁：不公平，可以插队（为了“公平”，引入非公平锁）–默认

3.3、Lock锁的使用

Lock锁“三部曲”：

1、创建锁对象

2、加锁

3、解锁

package com.my.demo;

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

//以买票为例
/*
 * 真正的多线程开发（公司中的）--降低耦合性（考虑怎么解耦？）
 *   把线程当作一个资源类，没有任何的附属操作
 *       1、属性。方法
 *
 * */
public class SaleTicket01 {
    public static void main(String[] args) {
        //并发：多个线程共享同一资源，把资源类丢入线程

        //重点理解怎么解耦？
        Ticket01 ticket = new Ticket01();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"C").start();
    }

}
//OOP编程
class Ticket01{
    private int number=20;

    Lock lock = new ReentrantLock();
    /*
    * Lock三部曲：
    *   1、new ReentrantLock();相当于创建锁
    *   2、lock.lock();//加锁
    *   3、lock.unlock();//解锁
    * */
    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.4、synchronized 和 Lock 的区别

synchronized 是内置的java关键字；Lock是一个接口，可以根据接口的实现类来创建Lock对象
synchronized 无法判断获取锁的状态；Lock锁可以判断是否获取到了锁
synchronized 会自动释放锁；lock必须手动释放锁,如果不释放锁,就会出现死锁现象
synchronized 如果有两个线程1和2，但是执行线程1时发生阻塞，那么线程2就会一直等待；Lock锁里面有个方法可以lock.tryLock();//尝试获取锁
synchronized 可重入锁,不可以中断,非公平;Lock 可重入锁,可以中断锁,非公平(可以自己设置)
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锁现象，来深入理解锁

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

普通同步方法（被synchronized关键字）“锁”的是方法调用者–phone对象（变量名）

同一个资源类中所有方法共用一把“锁”

所有线程被顺序创建，也就顺序打印

2、sendMessage延迟4秒，是先打印“发短信”还是“打电话”–（发短息打电话）

给第一个sendMessage方法延迟四秒

那么会出现一种状况：一秒后，在A线程还在等待“休眠”结束时，B线程开启，但是sleep方法仅仅是让正在执行的线程休眠而不是是否“锁”

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关键字的静态同步方法的区别
– synchronizef修饰普通同步方法时，锁的是类对象（多个对象对把锁）
– synchronized修饰静态同步方法时，锁的是类模板（一个对象只有一个）
普通方法和同步方法的区别
– 普通方法：不带锁的房间每个人都能进（可以进一人或多人）
– 同步方法：带锁的房间排队进（一把锁，只能进一人）

六、集合类不安全

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