多线程学习入门

最新推荐文章于 2022-12-22 15:59:08 发布

阿尼亚谁油

最新推荐文章于 2022-12-22 15:59:08 发布

阅读量185

点赞数

分类专栏：并发编程文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_44447809/article/details/125253652

版权

并发编程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

创建线程的方式总结

总结自狂神笔记

1、通过创建 Thread 的方式

子类继承 Thread 类具备多线程能力
启动线程：子类对象调用start()方法
不建议使用：避免OOP 单继承的局限性

      //(Create_01 类继承 Thread) 创建一个线程对象
        Create_01 create_01 = new Create_01();

        //调用start()开启线程
        create_01.start();

2、通过实现 Runnable 接口，再利用 Thread 的有参构造开启线程

实现接口 Runnable 接口具备多线程能力

启动线程：利用 Thread 类的有参构造（Runnable 实现类）创建对象，调用start()方法
推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个对象使用

多个线程去操作同一个资源的时候，比如卖票：就会出现超卖，同一张票卖给两个人等这种并发问题

public class Create_02_Test_02 implements Runnable {
    private int tickets = 20;

    @Override
    public void run() {
        //多个线程一起来买票
        while (true) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {


            }
            System.out.println("线程" + Thread.currentThread().getName() + "正在买第 " + tickets-- + "张火车票");
            if (tickets <= 0) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        Create_02_Test_02 tickets = new Create_02_Test_02();
        new Thread(tickets, "小满").start();
        new Thread(tickets, "小文").start();
        new Thread(tickets, "大帅").start();
    }
}

3、通过实现 Callable 接口重写 call()

创建执行服务 (通过Callable 来实现多线程的话必须和线程池绑定)

ExecutorService executorService = Executors.newFixedThreadPool(3);

提交执行

Future submitResult1 = executorService.submit(t1);
获取结果

System.out.println(submitResult1.get().toString());

注：Callable接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞
关闭服务

executorService.shutdown();

Runnable和Callable的区别

相同点

两者都是接口；（废话）
两者都可用来编写多线程程序；
两者都需要调用Thread.start()启动线程；

不同点

两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

注意点

Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

静态代理

1. 真实对象和代理对象都要实现同一个接口
2. 代理对象要代理真实角色

好处：

代理对象可以做很多真实对象做不了的事情以及对方法的拓展
真实对象专注做自己的事情

public class StaticProxy {

    public static void main(String[] args) {
       //new WeddingCompa(new MarryDomain()).marry("喜羊羊","美羊羊");
        
        new WeddingCompa((x,y)->{
            System.out.println("今天很高兴的告诉大家，"+x+"男士和"+y+"女士结婚了");
        }).marry("喜羊羊","美羊羊");


/*        new Thread(()->{
            System.out.println(123);
        }).start();*/

    }

}

`自己的理解`

使用静态代理说白了就是创建一个包装类，真正执行操作的还是原来对象。
要实现执行对象还是原来的操作那么代理类就要有原来对象的引用
既然决定包装那就要在真正执行操作操作之前前后加一些其他的处理操作

使用场景

 静态代理和动态代理都适用于以下场景
 1. 当不想访问某个对象或访问某个对象存在困难时，就可以为这个对象创建一个代理，通过代理来间接的访问这个对象；
 2. 如果原始对象有不同的访问权限，可以使用代理控制对原始对象的访问，保护原始对象；
 3. 在访问原始对象时执行一些自己的附加操作；
 4. 为某个对象在不同的内存地址空间提供局部代理，使得系统可以将服务端的实现隐藏，客户端不必考虑服务端的存在，

动态代理

Lambda 表达式

理解函数式接口，是学习lambda 表达式的关键

定义：

任何接口，如果只包含唯一一个抽象方法，那么他就是函数式接口。
例如 Runnable 接口
```
new Thread(()->{
 System.out.println(123);
 }).start();
```
对于函数式接口，我们可以通过lambda表达式创建该接口的对象

写法

Lambda 表达式的各种简化写法

方法一

Thread a = null;

    a = new Thread() {
        @Override
        public void run() {
            System.out.println(123);
        }
    };

方法2 可以简化为 Lambda 表达式

a = new Thread(()->{
        System.out.println(123);
    });

方法3 简化以后可以再简化去掉 {} 前提是代码只有一行

a = new Thread(()->
        System.out.println(123)
    );

Lambda 简单总结

Lambda 表达式只能有一行代码的情况才能简化为一行，如果有多行，那就用代码块包裹
必须是函数式接口，才能用Lambda 简写
多个参数时也可以去掉参数类型，只不过每个参数要么都去，要么都不去

线程操作

线程停止

建议线程正常停止
建议使用标志位来停止线程
不用使用stop()或者destroy()等过时或者jdk不推荐使用的方法

停止线程

public class test1 implements Runnable{
   static boolean flag  = true;
    @Override
    public void run() {
        int i = 0 ;
        while (flag){
            System.out.println("我正在执行 "+i);
            i++;
        }
    }
    public static void main(String[] args) {

    //  为什么不这么创建  new Thread(()->System.out.println("我是多线程")).start();
    // 这么创建多线程不用匿名内部类更多的时候是为了多个线程共同跑一个任务
    new Thread(new test1()).start();
    
    for (int i = 0; i < 1000; i++) {
        System.out.println("我是主线程，我正在跑第"+i+" 次");

        if (i==900){
            flag = false;
            System.out.println("我执行完了，bye bye ..");
            return;
        }
      }
    }
}

线程休眠

sleep(时间)指定当前线程阻塞的毫秒数
sleep()存在异常InterruptedException
sleep时间达到后，线程进入就绪状态
sleep 可以模拟网络延迟、倒计时等
每一个对象都有一个锁，sleep不会释放锁

/**

 * sleep 常用场景

 * 1、模拟网络延迟，放大问题的发现性（更容易暴露问题） --比如多人买票时，如果没有sleep，那么可能就看不到多人竞争的问题，进而也看不到由此引起的并发问题

 * 2、倒计时相关
   */
   public class testSleep {
   public static void main(String[] args) {
         turnDownNum();
   }
   //模拟倒计时
   public  static void turnDownNum(){
       int i = 5;
       while (true){
           try {
               Thread.currentThread().sleep(1000);
           } catch (InterruptedException e) {
           }
           System.out.println(i--);
           if (i<=0){
               return;
           }
       }

   }
 }

yield() 线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度，礼让不一定成功！看CPU心情

注意：如下代码中，创建Runnable 实现类的方式

public class testYield {
    public static void main(String[] args) {
     // 创建方式1 先创建一个类 实现Runnable 接口 重写run()
    Runnable a = new testYield2();

    //创建方式2 直接用匿名内部类操作
    Runnable aa = ()->{
        System.out.println(Thread.currentThread().getName()+" 线程开始执行了");
        yield();
        System.out.println(Thread.currentThread().getName()+" 线程执行结束了");
    };

    //创建；两个线程同时执行一个任务
    new Thread(a,"A").start();
    new Thread(a,"B").start();
}
static class testYield2 implements Runnable{
 @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" 线程开始执行了");
        yield();
        System.out.println(Thread.currentThread().getName()+" 线程执行结束了");
    }
  }
}

join() 插队线程

join()合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
可以理解为插队打饭，插入进来以后其他人等着，直到这人打完饭走了

public class testJoin {
    public static void main(String[] args) throws InterruptedException {
        Runnable a = () -> {
            for (int i = 0; i < 500; i++) {
                System.out.println("我是领导亲戚，我来插队 " + i);
            }
        };
        Thread thread = new Thread(a);
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("我正在排队打饭"+i);
            if (i==30){
                thread.join();
            }
            System.out.println("打完饭了，准备去打菜"+i);
        }
    }
}

线程的状态

传统模型

alt

   Thread t = new Thread();
线程对象一旦创建，就进入到了新生状态

就绪状态

当调用start(),线程立即进入就绪状态,但不意味着立即调度执行

运行状态

此时，经cpu调度以后，进入运行状态，这时线程才真正执行线程体的代码块

阻塞状态

当调用sleep wait 或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待CPU调度执行

dead

线程中断或者结束，一旦进入死亡状态，就不能再次启动

Java线程中的状态

具体可查看jdk文档

NEW 线程尚未启动的线程状态。
RUNNABLE 可运行线程的线程状态。可运行状态的线程正在Java虚拟机中执行，但它可能正在等待来自操作系统（例如处理器）的其他资源。
BLOCKED 一个线程的线程状态阻塞等待监视器锁定。处于阻塞状态的线程正在等待监视器锁定进入同步块/方法，或者在调用Object.wait后重新输入同步的块/方法。
WAITING 等待线程的线程状态由于调用以下方法之一，线程处于等待状态：

Object.wait没有超时
Thread.join没有超时
LockSupport.park

等待状态的线程正在等待另一个线程执行特定的动作。例如，已经在对象上调用Object.wait()线程正在等待另一个线程调用该对象上 Object.notify() Object.notifyAll()或。调用Thread.join()的线程正在等待指定的线程终止。

TIMED_WAITING 具有指定等待时间的等待线程的线程状态。线程处于定时等待状态，因为在指定的正等待时间内调用以下方法之一

Thread.sleep
```
Object.wait与超时
```
```
Thread.join与超时
```
```
LockSupport.parkNanos
```
```
LockSupport.parkUntil 
```

TERMINATED 终止线程的线程状态。线程已完成执行。

两种线程状态的区别

线程的优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级来决定应该调度哪个线程
来执行（不是唯一依据）
线程的优先级用数字表示，范围从1-10
- Thread.MIN_PRIORITY = 1
- Thread.NORM_PRIORITY = 5
- Thread.MAX_PRIORITY = 10
使用以下方式改变或者获取线程优先级
- getPriority()
- setPriority(int xxx)

注意：

优先级的设定，建议在start()之前
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度
优先级不能小于1 不能大于10 否则会报错

//测试线程优先级
public class testThreadPriority {
public static void main(String[] args) {

    System.out.println("我是主线程，我的优先级你自己看："+Thread.currentThread().getPriority());
    //创建任务
    Runnable task = () -> System.out.println(Thread.currentThread().getName() + "正在被执行，优先级是=====  " + Thread.currentThread().getPriority());

    Thread t1 = new Thread(task, "t1");
    Thread t2 = new Thread(task, "t2");
    Thread t3 = new Thread(task, "t3");
    Thread t4 = new Thread(task, "t4");
    Thread t5 = new Thread(task, "t5");
    Thread t6 = new Thread(task, "t6");
    
    
    t1.setPriority(5);
    t1.start();

    t2.setPriority(1);
    t2.start();

    t3.setPriority(7);
    t3.start();

    t4.setPriority(3);
    t4.start();

    t5.setPriority(Thread.MIN_PRIORITY);
    t5.start();

    t6.setPriority(Thread.MAX_PRIORITY);
    t6.start();

  }
}

优先级低的仍然有可能比优先级高的先执行

守护（daemon）线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完完毕
如后台记录操作日志、监控内存、垃圾回收等待


//测试守护线程
public class testThreadDdemon {
    public static void main(String[] args) {
        // 用户线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("我在开心的生活 第"+ i+"岁了");
            }
            System.out.println("=====拜拜，世界======");
        });
        Thread t2 = new Thread(() -> {
            while (true) {
                System.out.println("上帝一直在守护你，包轮你的后代");
            }
        });
           
        t2.setDaemon(true); //默认都是用户线程，设置以后为守护线程 虚拟机不会等待守护线程结束

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

并发问题

测试 ArrayList 的安全性

10000个线程去增加数据，最后集合内部可能不到一万，会存在多个线程竞争同一个数组下标的情况

package com.example.thread_study.unsafeTest;

import java.util.ArrayList;

/**
 * 测试 ArrayList 的线程不安全
 */
public class unsafeDemo02 {
    public static void main(String[] args) throws InterruptedException {
        ArrayList<String> threads = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread( () -> threads.add(Thread.currentThread().getName())).start();
        }
        Thread.currentThread().sleep(3000);
        System.out.println(threads.size());
    }
}

买票时的超卖问题

会卖出少于0 的票数

package com.example.thread_study.unsafeTest;

/**
 * 测试买票不安全的案例
 */
public class unSafeDemo01 {

    public static void main(String[] args) {
        saleTicket t = new saleTicket();
        new Thread(t,"英俊的我").start();
        new Thread(t,"丑陋的你").start();
        new Thread(t,"可恶的黄牛党").start();
    }

    static class saleTicket implements Runnable{
        private int tickets = 10;
        private volatile boolean flag = true;  //volatile 也不能解决并发问题
        @Override
        public void run() {
            while (flag){
                if(tickets<=0){
                    flag = false;
                }
                try {
                    Thread.currentThread().sleep(0);

                System.out.println(Thread.currentThread().getName()+"正在买第"+tickets+"张票");
                tickets--;

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

并发问题解决之：synchronized

synchronized是Java中的关键字，是一种同步锁。解决上述并发问题

由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，他包括synchronized方法和synchronized块
synchronized方法控制对对象的访问，每个对象对应一把锁，，每个synchronized方法必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
##　修饰的对象类型

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

解决并发问题

解决超卖问题

package com.example.thread_study.safeTest;

/**
 * 测试买票不安全的案例
 * 1、修饰代码块，作用的对象是调用这个代码块的对象
 */
public class SafeDemo01 {

    public static void main(String[] args) {
        saleTicket t = new saleTicket();
        new Thread(t,"英俊的我").start();
        new Thread(t,"丑陋的你").start();
        new Thread(t,"可恶的黄牛党").start();
    }

    static class saleTicket implements Runnable{
        private int tickets = 10;
        private  boolean flag = true;  //volatile 也不能解决并发问题
        @Override
        public void run() {
            synchronized (this){        //
                while (flag){
                    if(tickets<=0){
                        flag = false;
                    }
                    try {
                        Thread.currentThread().sleep(0);

                        System.out.println(Thread.currentThread().getName()+"正在买第"+tickets+"张票");
                        tickets--;

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }

}

ArrayList 的安全实现

// 方式1
/**
 * 测试 ArrayList 的线程安全 - synchronized
 */
public class safeDemo02 {
    public static void main(String[] args) throws InterruptedException {
        ArrayList<String> threads = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
              new Thread( () ->{
                  synchronized (threads){
                      threads.add(Thread.currentThread().getName()) ;
                  }
              }).start();
        }
        Thread.currentThread().sleep(3000);
        System.out.println(threads.size());
    }
}
//方式2

/**
 * 使用并发包保证线程安全
 */
public class safeDemo04 {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> threads = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
                new Thread(() ->
                    threads.add(Thread.currentThread().getName())
                ).start();
        }
        Thread.currentThread().sleep(3000);
        System.out.println(threads.size());
    }
}

死锁

死锁就是两个或两个以上线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

alt

示例

package com.example.thread_study.deadLock;

import static java.lang.Thread.sleep;

/**
 * 死锁形成原因：
 * 死锁就是两个或两个以上线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。
 */
public class Demo01 {
    public static void main(String[] args) {
        Object t1 = new Object();
        Object t2 = new Object();
        new Thread(() -> {
            try {
                synchronized (t1) {
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    sleep(2000);
                    synchronized (t2){
                        System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                synchronized (t2) {
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    sleep(2000);
                    synchronized (t1){
                        System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    }
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        /**
         *   触发了死锁  就是两个线程在各自拥有锁的情况下，又去尝试获取对方的锁，从而造成的一直阻塞
         */

    }
}

解决死锁

修改请求并持有条件：获得了一把锁之后不再去请求获取另一把锁
破坏环路等待条件：如果就是需要两把锁的资源，则可以按照如下流程进行操作
;
- 线程1得到锁A，线程②进入阻塞状态。
- 线程1去获取锁B，此时线程2仍然处于阻塞状态。
- 线程1执行完毕，释放锁B，释放锁A。
- 线程2获得锁A，继续执行。
- 线程2获得锁B。
- 线程2释放锁B。
- 线程2释放锁A，执行结束。

说白了就是两个线程获取锁的顺序一致就行，不要形成闭环的链路

package com.example.thread_study.deadLock;

import static java.lang.Thread.sleep;

/**
 * 死锁：解决
 *   1、修改请求并持有条件：获得了一把锁之后不再去请求获取另一把锁
 *   2、破坏环路等待条件：如果就是需要两把锁的资源，则可以按照如下流程进行操作
 */
public class Demo02 {
    public static void main(String[] args) {
        Object t1 = new Object();
        Object t2 = new Object();
        //方式1
 /*       new Thread(() -> {
            try {
                synchronized (t1) {
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    sleep(2000);

                }
                // 拥有一把锁的时候不要再去请求另外一把锁
                synchronized (t2){
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                synchronized (t2) {
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    sleep(2000);
                }
                // 拥有一把锁的时候不要再去请求另外一把锁
                synchronized (t1){
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();*/



        //方式2 破坏环路等待条件
        new Thread(() -> {
            try {
                synchronized (t1) {
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    sleep(2000);
                    synchronized (t2){
                        System.out.println(Thread.currentThread().getName()+"我拿到了第二把锁。。。哈哈哈");
                    }
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                synchronized (t1) {
                    System.out.println(Thread.currentThread().getName()+"我拿到了第一把锁。。。哈哈哈");
                    sleep(2000);
                    synchronized (t2){
                        System.out.println(Thread.currentThread().getName()+"我拿到了第二把锁。。。哈哈哈");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

并发问题解决之 LOCK锁

lock锁解决卖票超卖问题

package com.example.thread_study.lock;

import java.util.concurrent.locks.ReentrantLock;

public class lockDemo01 {
    public static void main(String[] args) {
        saleTicket t = new saleTicket();
        new Thread(t, "英俊的我").start();
        new Thread(t, "丑陋的你").start();
        new Thread(t, "可恶的黄牛党").start();
    }

    static class saleTicket implements Runnable {
        private int tickets = 10;
        private volatile boolean flag = true;  //volatile 也不能解决并发问题

        private ReentrantLock rtLock = new ReentrantLock();

        @Override
        public void run() {
               rtLock.lock();
            try {
                while (flag) {
                    if (tickets ==0) {
                        flag = false;
                        break;
                    }
                    Thread.currentThread().sleep(0);

                    System.out.println(Thread.currentThread().getName() + "正在买第" + tickets + "张票");
                    tickets--;

                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rtLock.unlock();
            }
        }
    }
}

synchronized与Lock的区别

Synchronized 是Java的一个关键字，而Lock是java.util.concurrent.Locks 包下的一个接口
Synchronized 使用过后，会自动释放锁，而Lock需要手动上锁、手动释放锁。（在 finally 块中）
Lock提供了更多的实现方法，而且可响应中断、可定时，而synchronized 关键字不能响应中断

eg:

Lock() ; //获取锁
tryLock(); //获取锁
tryLock(long time, TimeUnit unit); //在一定时间单位内等待后，尝试获取锁；
lockInterruptibly(); //获取锁，可响应中断；

synchronized关键字是非公平锁，即，不能保证等待锁的那些线程们的顺序，而Lock的子类ReentrantLock默认是非公平锁，但是可通过一个布尔参数的构造方法实例化出一个公平锁

PS：

公平锁与非公平锁：
```
		公平锁就是：先等待的线程，先获得锁。
		非公平锁就是：不能够保证 等待锁的 那些线程们的顺序，
		公平锁因为需要维护一个等待锁资源的队列，所以性能相对低下；
```
synchronized无法判断，是否已经获取到锁，而Lock通过tryLock()方法可以判断，是否已获取到锁；
Lock可以通过分别定义读写锁提高多个线程读操作的效率
二者的底层实现不一样：synchronized是同步阻塞，采用的是悲观并发策略；

Lock 只是一个顶层抽象接口，并没有实现，也没有规定是乐观锁还是悲观锁实现规则。而 ReentrantLock 作为 Lock 的一种实现，是悲观锁，https://blog.csdn.net/qq_35688140/article/details/101223701
ReentrantReadWriteLock 的提供了一种乐观锁的实现。
具体验证可以看看这个问题：https://ask.csdn.net/questions/774015

CAS算法：

CAS，即Compare And Swap，意思是：比较并替换。
CAS算法需要3个操作数：内存地址V，旧预期值A，将要更新的目标值B。
CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作。
CAS是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。　　　
通常将 CAS算法用于同步的方式是：从地址 V 读取值 A，执行多步计算来获得新值B，然后使用 CAS算法将 V 的值从 A 改为 B。如果 V 处的值尚未同时更改，则 CAS 操作成功。

线程通信

解决方式一：管程法

并发协作模型“生产者/消费者模式”----> 管程法

生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿数据

package com.example.thread_study.threadChat;

/**
 * 线程通信之  生产消费者模型
 * --- 利用缓冲区解决：管程法
 * -- 生产者 消费者 产品 缓冲区
 */
public class Demo1 {
    public static void main(String[] args) {
        productStore store = new productStore();
        new Producter(store).start();
        new Consumer(store).start();
    }

    //生产者
    static class Producter extends Thread {
        productStore p;

        private Producter(productStore p) {
            this.p = p;
        }

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                System.out.println("生产者正在生产第 " + i + " 只鸡");
                p.push(new Chicken(i));
            }
        }
    }

    //消费者
    static class Consumer extends Thread {
        productStore p;

        private Consumer(productStore p) {
            this.p = p;
        }

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                Chicken pop = p.pop();
                System.out.println("消费者正在吃第 " + pop.id + " 只鸡");
            }
        }
    }

    // product 产品
    static class Chicken {
        private int id;

        public Chicken(int i) {
            this.id = i;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }
    }

    //缓冲区/仓库
    static class productStore {
        //初始化仓库大小
        Chicken[] products = new Chicken[10];
        //开始时里面没有产品
        int count = 0;

        //存产品
        private synchronized void push(Chicken chicken) {
            //仓库满了  等待消费者消费
            if (count == products.length) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //生产者生产的鸡放进去
            products[count] = chicken;

            count++;

            //通知消费者可以来消费了
            this.notifyAll();

        }


        //取产品
        private synchronized Chicken pop() {
            //如果没有 等待生产者生产
            if (count == 0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            count--;
            //如果仓库有货 直接消费
            Chicken product = products[count];
            // 通知生产者 鸡被我吃了
            this.notifyAll();
            //把刚吃的鸡返回
            return product;


        }

    }

}

解决方式二：信号灯法

并发协作模型“生产者/消费者模式”----> 信号灯法

package com.example.thread_study.threadChat;

/**
 * 实例2： 信号灯法
 */
public class Demo02 {
    public static void main(String[] args) {
        tv tv = new tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }

    //演员
    static class Player extends Thread {
        tv myTv;

        private Player(tv tv) {
            this.myTv = tv;
        }

        @Override
        public void run() {
            for (int i = 0; i < 40; i++) {
                if (i % 2 == 0) {
                    myTv.play("武松大战潘金莲");
                } else {
                    myTv.play("哪吒闹小河");
                }
            }
        }
    }

    //观众
    static class Watcher extends Thread {
        tv myTv;

        private Watcher(tv tv) {
            this.myTv = tv;
        }

        @Override
        public void run() {
            for (int i = 0; i < 40; i++) {
                myTv.watch();
            }
        }
    }

    static class tv {
        String program;
        volatile boolean flag = true;// true 表演  false 等待

        private synchronized void play(String program) {
            try {
                if (!flag) {
                    this.wait();
                }

            } catch (InterruptedException e) {
            }
            System.out.println("演员正在表演：" + program);
            this.program = program;
            this.flag = !flag;
            this.notifyAll();
        }

        private synchronized void watch() {
            if (flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("我们正在 观看节目：" + program);
            this.flag = !flag;
            this.notifyAll();
        }

    }

}

private Watcher(tv tv) {
this.myTv = tv;
}

    @Override
    public void run() {
        for (int i = 0; i < 40; i++) {
            myTv.watch();
        }
    }
}

static class tv {
    String program;
    volatile boolean flag = true;// true 表演  false 等待

    private synchronized void play(String program) {
        try {
            if (!flag) {
                this.wait();
            }

        } catch (InterruptedException e) {
        }
        System.out.println("演员正在表演：" + program);
        this.program = program;
        this.flag = !flag;
        this.notifyAll();
    }

    private synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("我们正在 观看节目：" + program);
        this.flag = !flag;
        this.notifyAll();
    }

}

}