coolgwayne

厚积薄发打卡Day26：狂神说Java之JUC并发编程＜代码+笔记＞（上）

前言：

学习视频来源：【狂神说Java】JUC并发编程最新版通俗易懂

一个十分优秀且励志的技术大牛+Java讲师，十分推荐他的频道：遇见狂神说

至于为啥这篇文章不是”全网最全“了，是因为狂神自己总结了一份学习笔记哈哈，本文是根据学习资料自己总结，方便以后查漏补缺

狂神置顶评论：

(置顶) 白漂有罪，拒绝白嫖，从点赞转发关注做起！
文章同步在公众号：狂神说（公众号日更，记得关注）
视频文档地址：https://gitee.com/kuangstudy/openclass 记得三连➕转发

本文截止至异步回调 ，从 JMM 开始分为下篇。

好，接下来就正式开始 ”勾优西 “ 的学习了~

前置知识：学习JUC前需要对java的多线程有一定的掌握。不过本期视频狂神也在第1~4节带着我们回顾了多线程的一些知识点：

详细资料可参考博客：厚积薄发打卡Day25 ：狂神说Java之多线程详解＜全网最全(代码+笔记)＞

0.学习方法

源码+官方文档：

其实官方文档就是源码编译出来的，其本质还是看源码，不过文档会比较方便学习

只有多看源码，多研究文档才会进步
Java英文文档可以通过点击查看源码获取
Java1.8中文文档（中文 – 谷歌版）
- 在线版: https://blog.fondme.cn/apidoc/jdk-1.8-google/
- 下载链接： https://pan.baidu.com/s/10wTC1F_4EUPsHzrn-_sPTw 密码：k7rm

1.什么是JUC

JUC其实就是Java.Util.concurrent包的缩写

java.util.concurrent
java.util.concurrent.atomi
java.util.concurrentlocks

是 java.util 工具包、包、分类

回顾开启线程的三种方式：
1. Thread
2. Runnable
3. Callable

2.线程与进程

线程、进程，如果不能使用一句话说出来的技术，不扎实！

打开（Win10）任务管理器可以清楚看到执行的线程与进程：

参考博客：什么是线程？什么是进程

进程：
- 官方定义：
  
  进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础
- 简单理解：
  
  进行（运行）中的程序，如打开任务管理器后中各种.exe程序
线程：
- 官方定义：
  
  线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
- 简单理解：
  
  线程是真正执行资源调度（使程序跑起来）的主体，一个进程往往可以包含多个线程，但至少包含一个线程。
  
  如：开一个idea进程，其中至少有—> 线程1：输入代码，线程2：自动保存

老是强调多线程，那么 Java真的可以开启线程吗？

答案是 : 不能。查看Thread.start()源码可得知：

public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}
// 本地方法，底层的C++ ，Java 无法直接操作硬件
private native void start0();

并发编程

并发编程：并发、并行

并发（多线程操作同一个资源）
- CPU 一核，模拟出来多条线程，天下武功，唯快不破，快速交替
并行（多个人一起行走）
- CPU 多核，多个线程可以同时执行；线程池

public class Test1 {
    public static void main(String[] args) {
        // 获取cpu的核数
        // CPU 密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
       //输出为8
        //说明笔者电脑为八核处理器
    }
}

线程的几个状态：

从源码回答，有理有据

public enum State {
    // 新生
    NEW,
    // 运行
    RUNNABLE,
    // 阻塞
    BLOCKED,
    // 等待，死死地等
    WAITING,
    // 超时等待
    TIMED_WAITING,
    // 终止
    TERMINATED;
}

wait与sleep的区别

看源码说话嗷
```
//Object.wait()
public final void wait() throws InterruptedException {
    wait(0);
}

//Thread.sleep()
public static native void sleep(long millis) throws InterruptedException;
```
1. 来自不同的类
  1. wait() 来自 Object类
  2. sleep() 来自 Thread类
2. 关于锁的释放
  1. wait() 会释放锁：wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。
  2. sleep() 不出让系统资源；（简单来说，就是抱着睡觉）
3. 是否需要捕获异常？
  
  需要。源码都在上面写的死死的，throws InterruptedException 都不知网上随手一搜的博客说wait() 不用捕获异常怎么搞得。
  
  好吧，回看了下视频，狂神好像也翻车了哈哈
4. 使用范围：
  1. wait() 需要在同步代码块中使用
```
// wait、notify/notifyAll必须在同步控制块、同步方法里面使用。而sleep的使用在任意地方。
synchronized(x){
    x.notify()
   //或者wait()
}
```
  2. sleep()可以在任何地方睡
5. 作用对象：
  1. wait()定义在Object类中，作用于对象本身
  2. sleep()定义在Thread 类中，作用当前线程。
6. 方法属性：
  1. wait()是实例方法
  2. sleep()是静态方法有static

3.Lock锁(重点)

回顾用传统的 synchronized 实现 线程安全的卖票例子

真正的多线程开发，公司中的开发，降低耦合性

线程就是一个单独的资源类，没有任何附属的操作！

对于资源类只有：属性、方法

开启线程错误方式：
class Ticket implements Runnable{}
耦合度高，违背了oop(面向对象)思想

public class SaleTicket_WithSynchronized {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类, 把资源类丢入线程
        Ticket ticket = new Ticket();
        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.saleTicket();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.saleTicket();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.saleTicket();
            }
        }, "C").start();

    }
}

//资源类 OOP：
class Ticket {
    //属性、方法
    private int number = 30;
    //卖票方法
    //用synchronized 上锁
    public synchronized void saleTicket() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票，剩余" + number + "张");
        }
    }
}

用Lock接口

Lock源码定义：

常用上锁语句：

Lock l = ...;
l.lock();   //加锁
try { // access the resource protected by this lock
} 
finally 
{ l.unlock(); //解锁}

ReentrantLock 可重入锁
公平锁与非公平锁（简单认识，后面详解）
- 公平锁：非常公平，不能够插队，必须先来后到！
- 非公平锁：非常不公平，可以插队（默认都是非公平）
上案例

// Lock 三部曲
// 1、 new ReentrantLock();
// 2、 lock.lock(); // 加锁
// 3、 finally=> lock.unlock(); // 解锁
public class SaleTicket_WithLock {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类, 把资源类丢入线程
        Ticket ticket = new Ticket();
        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.saleTicket();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.saleTicket();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.saleTicket();
            }
        }, "C").start();

    }

}

class Ticket2 {
    // 属性、方法
    private int number = 30;
    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(); // 解锁
        }
    }
}

Synchronized 和 Lock 区别

Java中的锁——Lock和synchronized

4、相比于synchronized，Lock接口所具备的其他特性

①尝试非阻塞的获取锁tryLock()：当前线程尝试获取锁，如果该时刻锁没有被其他线程获取到，就能成功获取并持有锁

②能被中断的获取锁lockInterruptibly()：获取到锁的线程能够响应中断，当获取到锁的线程被中断的时候，会抛出中断异常同时释放持有的锁

③超时的获取锁tryLock(long time, TimeUnit unit)：在指定的截止时间获取锁，如果没有获取到锁返回false

	synchronized	Lock
性质	Java的内置关键字，在JVM层面上	Java类（接口）
锁的释放	1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁	必须要手动释放锁，如果不释放锁，会造成死锁
锁的获取	假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待	分情况而定，Lock有多个锁获取的方式：大致就是可以尝试获得锁，线程可以不用一直等待
锁状态	无法判断	可以判断
锁类型	可重入不可中断非公平	可重入可判断可公平（两者皆可，可手动设置）

4.生产者消费者问题

从pc（producer<–>consumer）问题看锁的本质

1.synchronized版本

生产者消费者synchronized版本

案例：对一个数字不停进行 +1 -1操作，加完了减，减完了加

public class PC_WithSynchronized {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"ADD").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"MINUS").start();
    }
}
//判断等待-->业务代码-->通知
//数字：资源类
class Data{
    //属性
    private int number = 0;
    //+1方法
    public synchronized  void increment() throws InterruptedException {
        if (number != 0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"-->"+number);
        //加完了通知其他线程
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"-->"+number);
        //减完了通知其他线程
        this.notifyAll();
    }
}

此时输出：

加减交替执行，一片祥和~

..
ADD-->1
MINUS-->0
ADD-->1
MINUS-->0
ADD-->1
MINUS-->0
ADD-->1
MINUS-->0
ADD-->1
MINUS-->0
...

问题来了，现在只有"ADD"和"MINUS"两个线程执行操作，如果增加多两个线程会怎样呢？

于是在main方法中增加了"ADD2" 和 "MINUS2"两条线程：

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

出大问题了：出现了数据错误甚至死锁问题

原因如下：

用if判断只执行了一次判断，而wait()方法会导致的释放
具体说明：以两个加法线程ADD、ADD2举例：
- 比如ADD先执行，执行时调用了wait方法，那它会等待，此时会释放锁。
- 那么线程ADD2 获得锁并且也会执行wait()方法，且释放锁，同时两个加线程一起进入等待状态，等待被唤醒。
- 此时减线程中的某一个线程执行完毕并且唤醒了这俩加线程（notifyAll），那么这俩加线程不会一起执行，其中ADD获取了锁并且加1，执行完毕之后ADD2再执行。
- 如果是if的话，那么ADD修改完num后，ADD2不会再去判断num的值，直接会给num+1,如果是while的话，ADD执行完之后，ADD2还会去判断num的值，因此就不会执行。
上述情况称为：虚假唤醒
此时解决方法：将 if 改为 while

package com.kuangstudy.JUC;

/**
 * @BelongsProject: itstack-demo-design-1-00
 * @BelongsPackage: com.kuangstudy.JUC
 * @Author: lgwayne
 * @CreateTime: 2021-02-20 17:32
 * @Description:
 */
public class PC_WithSynchronized {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"ADD").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"MINUS").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"ADD2").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"MINUS2").start();
    }
}
//判断等待-->业务代码-->通知
//数字：资源类
class Data{
  //data类相同，不再赘述
}

结果一片祥和~

...
ADD2-->1
MINUS2-->0
ADD2-->1
MINUS2-->0
ADD2-->1
MINUS2-->0
ADD2-->1
MINUS2-->0
ADD2-->1
MINUS2-->0
...

2.JUC的船新版本

通过Lock找到condition来配合控制对线程的唤醒

public interface Condition
Condition因素出Object监视器方法（ wait ， notify和notifyAll ）成不同的对象，以得到具有多个等待集的每个对象，通过将它们与使用任意的组合的效果Lock个实现。 Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。

public class PC_WithLock {
    public static void main(String[] args) {
        //主线程测试方法与上述一致，不再赘述
    }
}

//判断等待-->业务代码-->通知
//数字：资源类
class Data_withLock {
    //属性
    private int number = 0;

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1方法
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "-->" + number);
            //加完了通知其他线程
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "-->" + number);
            //减完了通知其他线程
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

3.wait()与await() 区别

两种在表现上有点相似，但是作用机制是有区别的

wait()来自Object await()来自condition
object wait() 不能单独使用，必须是在synchronized 下才能使用

为啥强制wait必须用在synchronized中？否则IllegalMonitorStateException

（1）为什么wait()必须在同步（Synchronized）方法/代码块中调用？

答：调用wait()就是释放锁，释放锁的前提是必须要先获得锁，先获得锁才能释放锁。

（2）为什么notify(),notifyAll()必须在同步（Synchronized）方法/代码块中调用？

答：notify(),notifyAll()是将锁交给含有wait()方法的线程，让其继续执行下去，如果自身没有锁，怎么叫把锁交给其他线程呢；
————————————————
原文链接：https://blog.csdn.net/qq_42145871/article/details/81950949
wait()必须要通过notify()方法进行唤醒
await() 必须是当前线程被排斥锁 lock 后,，获取到condition 后才能使用

条件变量的await()释放锁吗？

await()的作用是能够让其他线程访问竞争资源，所以挂起状态就是要释放竞争资源的锁。在javaSE5的java.util.concurrent类库中，使用互斥并允许任务挂起的基本类就是Condition，你可以通过await()来挂起一个任务，当外部条件改变时，意味着某个任务可以继续执行，你可以通过signal()来通知这个任务。

每个lock()的调用必须紧跟一个try-finally子句，用来保证在所有情况下都可以释放锁。任务在可以调用await(),signal(),signalAll()之前，必须拥有这个锁
condition await() 必须通过 signal() 方法进行唤醒

4.使用condition实现精准唤醒线程

用condition搭配状态位置试试

public class PC_WithAwakeByCondition {
    public static void main(String[] args) {
        Data_AwakeInOrder data = new Data_AwakeInOrder();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"线程A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"线程B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"线程C").start();
    }
}

//资源类
class Data_AwakeInOrder{
    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();
            }
            System.out.println(Thread.currentThread().getName() + "=>AAAAAA"+"-----number为->"+number);
            // 唤醒，唤醒指定的人，B
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            // 业务，判断-> 执行-> 通知
            while (number != 2) {
                // 等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBBBBB"+"-----number为->"+number);
            // 唤醒，唤醒指定的人C
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            // 业务，判断-> 执行-> 通知
            while (number != 3) {
                // 等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>CCCCCC"+"-----number为->"+number);
            // 唤醒，唤醒指定的人A
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果：一片祥和~依序执行

...
线程A=>AAAAAA-----number为->1
线程B=>BBBBBB-----number为->2
线程C=>CCCCCC-----number为->3
线程A=>AAAAAA-----number为->1
线程B=>BBBBBB-----number为->2
线程C=>CCCCCC-----number为->3
...

看视频的时候看到有人用wait和notify 也实现了精准唤醒，接下来稍作尝试

5.使用wait()与notify()实现精准唤醒

public class PC_AwakeWithWait {
    public static void main(String[] args) {
        Data_AwakeInOrderByWait data = new Data_AwakeInOrderByWait();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                data.printA();
            }
        },"T_A").start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                data.printB();
            }
        },"T_B").start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                data.printC();
            }
        },"T_C").start();
    }
}

//资源类
class Data_AwakeInOrderByWait{

    private int number = 1;

    public synchronized void printA() {
        // 业务，判断-> 执行-> 通知
        while (number != 1) {
            // 等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "=>AAAAAA->"+number);
        // 唤醒，唤醒指定的人，B
        number = 2;
        this.notifyAll();
    }

    public synchronized void printB(){
        // 业务，判断-> 执行-> 通知
        while (number != 2) {
            // 等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "=>BBBBBB->"+number);
        // 唤醒，唤醒指定的人，B
        number = 3;
        this.notifyAll();

    }
    public synchronized void printC(){
        // 业务，判断-> 执行-> 通知
        while (number != 3) {
            // 等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "=>CCCCCC->"+number);
        // 唤醒，唤醒指定的人，B
        number = 1;
        this.notifyAll();
    }
}

结果也确实可以实现精准唤醒：

...
T_A=>AAAAAA->1
T_B=>BBBBBB->2
T_C=>CCCCCC->3
T_A=>AAAAAA->1
T_B=>BBBBBB->2
T_C=>CCCCCC->3
...

后来的技术是迭代出的更优秀的版本。等学成归来对比下这两种唤醒的效率

5.8个代码加锁的例子

用4套八种加锁的例子对比理解锁的本质

情况一：实例化一个对象

连续十次执行线程，A/B两条线程交替执行

public class Test1 {
    public static void main(String[] args) {

        Phone phone = new Phone();
        for (int i = 0; i < 10; i++) {
            //锁的存在
            new Thread(() -> {
                phone.sendSms();
            }, "A").start();

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

class Phone {
    public synchronized void sendSms() {
        System.out.println("发短信###");
    }
    public synchronized void call() {
        System.out.println("打电话******");
    }
}

...
发短信###
打电话******
打电话******
打电话******
发短信###
...

在线程执行的过程中增加sleep()休眠（Phone类不变）

public static void main(String[] args) {
        Phone phone = new Phone();
        for (int i = 0; i < 10; i++) {
            //锁的存在
            new Thread(() -> {
                phone.sendSms();
            }, "A").start();

            //增加0.5s的休眠时间
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            new Thread(() -> {
                phone.call();
            }, "B").start();
        }
    }

发短信###
打电话******
发短信###
打电话******

结果：

发短信—>打电话

依次执行

在Phone的发短信的方法中增加2s的休眠（main方法不变）

class Phone {
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信###");
    }

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

结果：

发短信—>打电话

依次执行

总结
- synchronized 锁的对象是方法的调用者，也就是实例化后的对象。
- 两个方法用的是同一个锁，谁先拿到谁执行！
  - 在例子中，线程的调度是随机的，但是由于实例抱着休眠，因此线程极大可能（几乎一定）会先执行首个即发短信方法

情况二：实例化一个对象

两个对象，两个调用者，两把

两个问题：

3. 增加了一个普通方法后！先执行发短信还是Hello？ 普通方法
4. 两个对象，两个同步方法， 发短信还是 打电话？ // 打电话

例子：

public class Test2  {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        //锁的存在
        new Thread(phone1::sendSms,"A").start();

        new Thread(phone1::hello,"C1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(phone2::call,"B").start();

        new Thread(phone2::hello,"C2").start();
    }
}

class Phone2{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信sssss <--"+Thread.currentThread().getName());
    }

    public synchronized void call(){
        System.out.println("打电话cccc <--"+Thread.currentThread().getName());
    }

    public void hello(){
        System.out.println("hello <--"+Thread.currentThread().getName());
    }
}

运行结果（多次）

hello <--C1
打电话cccc <--B
hello <--C2
发短信sssss <--A

总结：
- synchronized 锁的对象是方法的调用者，也就是实例化后的对象。
- 普通方法不会上，因此会首先打印hello
- A 线程调用 sendSms 时延时了 2s，因此会先调用B线程的发短信方法

情况三：静态方法

问题：

5.增加两个静态的同步方法，只有一个对象，先打印 发短信?打电话?
6.两个对象！增加两个静态的同步方法， 先打印 发短信?打电话?

例子1（实例化一个对象）

public class Test3  {
    public static void main(String[] args) {
        Phone3 phone1 = new Phone3();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}
class Phone3{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

运行结果：

发短信 -->打电话

例子2：(实例化两个对象)

Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
new Thread(()->{
    phone1.sendSms();
},"A").start();
try {
    TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
    e.printStackTrace();
}
//另一个实例化对象
new Thread(()->{
    phone2.call();
},"B").start();

运行结果：

发短信 -->打电话

总结：
- 两个对象的Class类模板只有一个，static方法时在类加载的时候初始化，因此锁的是Class对象
- 在休眠后（极大可能）调用发短信对象，同时对模板上，因此依次打印

情况四：静态与普通方法

问题：

7.1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？
8.1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？

例子7：

public class Test4  {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}
class Phone4{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

运行结果：
- 打电话 --> 发短信

例子8：

        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();

运行结果：
- 打电话 --> 发短信

总结：
- 普通方法的是对象
- static 方法的是模板

双冒号表达式：

插播一个知识点，双冒号(::)表达式

详见：JAVA 8 ‘::’ 关键字，带你深入了解它！

语法种类示例

引用静态方法 ContainingClass::staticMethodName

引用特定对象的实例方法 containingObject::instanceMethodName

引用特定类型的任意对象的实例方法 ContainingType::methodName

引用构造函数 ClassName::new

语法种类	示例
引用静态方法	ContainingClass::staticMethodName
引用特定对象的实例方法	containingObject::instanceMethodName
引用特定类型的任意对象的实例方法	ContainingType::methodName
引用构造函数	ClassName::new

举例：

//表达式转换
 new Thread(() -> {
                phone.call();
            }, "B").start();
//可以转换成：
new Thread(phone::call,"B").start();

6.集合不安全类

List不安全

在狂神多线程的三个线程不安全的案例中有提及，今天在并发角度测试下

public class TestList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
             list.add(UUID.randomUUID().toString().substring(0,5));
             System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

执行程序后会抛出：

java.util.ConcurrentModificationException异常（后续抛出同样异常不做细说）

也就是不同线程同时操作了同一list索引元素抛出的异常。

解决方法：

public static void main(String[] args) {
    //        List list = new ArrayList<>();
    //1.集合自带的线程安全的list
    //        List list = new Vector<>();

    //2.Collections工具类强行上锁
    //        List list =Collections.synchronizedList(new ArrayList<>());

    //3.用JUC包下的读写数组CopyOnWriteArrayList，读写分离
    List<String> list = new CopyOnWriteArrayList<>();
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            list.add(UUID.randomUUID().toString().substring(0, 5));
            System.out.println(list);
        }, String.valueOf(i)).start();
    }
}

Set不安全

例子：

public class TestSet {
    public static void main(String[] args) {
        Set<Object> set = new HashSet<>();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }
}

解决方法：

public static void main(String[] args) {
    //        Set

	第一组	第二组	第三组	第四组
实现结果	有返回值会抛异常的方法	有返回值但不抛异常的方法	线程会阻塞和等待的方法（一直等待）	超时等待的方法（过时不候）
添加元素	add(E e)	offer(E e)	put(E e)（无返回值）	offer(E e, long timeout, TimeUnit unit)
移除元素	remove()	poll()	take()	poll(long timeout, TimeUnit unit)
检测队首元素	element()	peek()	无。上述两个方法会`throws InterruptedException`	无。上述两个方法会`throws InterruptedException`

厚积薄发打卡Day26：狂神说Java之JUC并发编程＜代码+笔记＞（上）

前言：

0.学习方法

1.什么是JUC

2.线程与进程

并发编程

线程的几个状态：

wait与sleep的区别

3.Lock锁(重点)

Synchronized 和 Lock 区别

4.生产者消费者问题

1.synchronized版本

2.JUC的船新版本

3.wait()与await() 区别

4.使用condition实现精准唤醒线程

5.使用wait()与notify()实现精准唤醒

5.8个代码加锁的例子

情况一：实例化一个对象

情况二：实例化一个对象

情况三：静态方法

情况四：静态与普通方法

总结：

双冒号表达式：

6.集合不安全类

List不安全

Set不安全

Map不安全

7.Callable使用

8. JUC常用辅助类

8.1 CountDownLatch

8.2 CyclicBarrier

8.2.1 lambda为什么要用final？

8.3 Semaphore

9.读写锁

10.阻塞队列

四组API

SynchronousQueue 同步队列

11.线程池（※）

11.0 池化技术

11.1 三大方法

11.2 七大参数

11. 2.1 手动创建线程池：

11.4 四种拒绝策略

11.5小结：

12.四大函数式接口

Consumer

双冒号

Function

Predicate

Supplier

13. Stream流式计算

流的简单介绍

如何生成流

14. Fork/Join

15.异步回调:

你可能感兴趣的:(狂神说Java学习,Java基础进阶,Java并发,java,队列,juc,并发,并发编程)