小黑子—Java从入门到入土过程：第十章 - 多线程

Java系列第十章- 多线程

1. 初识多线程

进程：

进程是程序的基本执行实体

线程：

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位

举个例子：360

360这个软件运行之后，它的本身是一个进程，而它的电脑清理、木马查杀、系统修复、优化加速，就可以把其看作是4个线程

像这样互相独立的、能同时运行的功能比较多的线程，被称为多线程

多线程和单线程的区别
对比单线程：

程序从头往下依次运行，cpu不会切换到其他代码中去运行，可见单线程效率比较低

多线程的特点：

能同时的去做多件事情，cpu可以在多个程序之间切换，把等待的空闲时间充分利用起来

小结：

2. 并发和并行

并发：

比如人相当于CPU，交替行为作为线程，在玩游戏时，想要做其他的事情

并行


电脑CPU：线程的数量就表示电脑能同时运行多少条线程

举例4线程：如果说计算机当中有4个线程就不用切换

但是线程越来越多时，4条红线就会在多个线程之间随机进行切换，所以在计算机当中并发和并行就可能是同时发生的

小结：

3. 多线程的实现方式

3.1 一：继承Thread类方式实现

线程是程序中的执行线程。Java虚拟机允许应用程序并发地运行多个线程
每一个Thread类都是一个并发的线程
创建新执行线程有两种方法。
一种方法是将类声明为Thread的子类。该子类应重写Thread类的run方法。
接下来可以分配并运行该子类的实例

多线程的第一种启动方式;

1. 自己定义一个类继承Thread
2. 重写run方法
3. 创建子类的对象，并启动线程

MyThread类：
public class MyThread extends Thread{
    @Override
    public void run(){
        //书写线程要执行的代码
        for (int i = 0; i < 20; i++) {
            System.out.println(getName()+"HelloWorld");
        }
    }
}

测试类：
public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程1");
        t2.setName("线程2");

        //MyThread里的start才表示开启线程
        t1.start();
        t2.start();
    }
}

3.2 二：实现Runnable接口的方式实现

创建线程的另一种方法是声明实现Runable接口的类。该类然后实现run方法。然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动。

多线程的第二种启动方式:

1. 自己定义一个类实现Runnable接口
2. 重写里面的run方法
3. 创建自己的类的对象
4. 创建一个Thread类的对象，并开启线程

MyRun类：
public class MyRun implements Runnable{
    @Override
    public void run(){
        //书写线程要执行的代码
        for (int i = 0; i < 20; i++) {
            //获取当前线程的对象Thread.currentThread()，用对象再次调用方法
            System.out.println(Thread.currentThread().getName()+"HelloWorld");
            //这里不能直接调用getName了，因为这个方法是在thread当中的，这个接口没有这个方法的继承关系
            //刚刚的MyThread是在子类里面调用父类里面的方法，所以没问题

        }
    }
}


测试类：
public class Test {
    public static void main(String[] args) {
        //创建MyRund对象
        MyRun mr = new MyRun();
        //创建线程对象
        Thread t1 = new Thread(mr);
        t1.setName("线程1");

        Thread t2 = new Thread(mr);
        t2.setName("线程2");

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

3.3 三：利用Callable接口和Future接口方式实现

特点:可以获取到多线程运行的结果

1. 创建一个类MyCallable实现Callable接口
   
   这个接口是有泛型的，表示结果。如果说想要开启一个类型让其求1~100的整数和，那么其结果也肯定是一个整数类型，那么此时泛型就可以写Integer

2. 重写call(是由返回值的,表示多线程运行的结果)

3. 创建MyCallable的对象(表示多线程要执行的任务)

4. 创建FutureTask的对象(作用管理多线程运行的结果)

5. 创建Thread类的对象,并启动(表示线程)

MyCallable类：
public class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum = sum + i;
        }
        return sum;
    }
}

测试类：
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        //创建`FutureTask`的对象(作用管理多线程运行的结果)
        FutureTask<Integer> ft = new FutureTask<>(mc);//相当于yongFutureTask对象管理 mc这个对象的结果
        //创建线程的对象
        Thread t1 = new Thread(ft);
        //启动线程
        t1.start();

        //获取多线程的运行结果
        Integer res = ft.get();
        System.out.println(res);
    }

多线程三种实现方式对比：

对比	优点	缺点
继承Thread类	编程比较简单，可以直接使用Thread类中的方法	可以拓展性差，不能再继承其他类，无法获得多线程的结果
实现Runable接口	拓展性强，实现该接口的同时还可以继承其他的类，可以获得多线程的结果	编程相对复杂，不能直接使用Thread类中的方法，无法获得多线程的结果
实现Callable接口	拓展性强，实现该接口的同时还可以继承其他的类	编程相对复杂，不能直接使用Thread类中的方法

4. 多线程中常见的成员方法

4.1 线程名字

细节:

• 如果没有给线程设置名字,线程也是有默认的名字的 格式:Thread-X(X序号,从0开始的) Thread构造方法也可以设置Thread的名字

• 如果要给线程设置名字，可以用set方法进设置，也可以构造方法设置

MyThread类：
public class MyThread extends Thread{
    //之前通过setName在父类添加名字，而在测试类中在子类对象MyThread进入写入名字报错，是因为子类不能调用父类的构造方法
    //构造方法是不能继承的，如果说子类想要使用父类的构造，就要自己去写一个新的然后利用super去调用父类的构造


    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

测试类：
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("瓜皮");
        MyThread mt2 = new MyThread("麻瓜");

        //开启线程
        mt1.start();
        mt2.start();
    }

4.2 Thread.currentThread 获取当前线程的对象

细节：

1. 当JVM虚拟机启动之后，会自动的启动多条线程
2. 其中有一条线程就叫做main线程
3. 他的作用就是去调用main方法，并执行里面的代码
4. 在以前，我们写的所有代码，其实都是运行main线程当中的

测试类：
    public static void main(String[] args) {
        //哪条线程执行到这方法，此时获取的就是哪条线程的对象
        Thread t = Thread.currentThread();
        String name = t.getName();
        System.out.println(name);
    }

4.3 sleep 让线程休眠指定的时间

关于sleep细节:

1. 哪条线程执行到这个方阿飞,那么哪条线程就会在这里停留对应的时间
2. 方法的参数:就表示睡眠的时间,单位毫秒 1秒等于1000毫秒
3. 当时间到了以后，线程会自动的醒来，继续执行下面的其他代码

    public static void main(String[] args) throws InterruptedException {
        System.out.println("aaaaaaaaa");
        Thread.sleep(5000);//稍等5秒钟，才打印下方
        System.out.println("66666666666");
    }

利用这个方法，在开启线程的时候，可以设置执行的时间
例如：

4.4 线程的优先级

线程调度：
抢占式调度：

抢夺cpu的执行权（就是个随机,谁抢到算谁的,时间长短也随机），重点掌握其随机性

非抢占式调度：

表示所有的线程轮流的调度，执行的时间也是差不多的

java中是采取抢占式调度
而优先级越大，那么抢到cpu的概率就越大

 MyRunnable类：
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"@"+i);
        }
    }
}

测试类：
    public static void main(String[] args) {
        //创建线程要执行的参数对象
        MyRunnable mr = new MyRunnable();

        //创建线程对象
        Thread t1 = new Thread(mr,"麻瓜");
        Thread t2 = new Thread(mr,"愣头青");

        System.out.println(t1.getPriority());//默认的5
        System.out.println(t2.getPriority());//默认的5
        System.out.println(Thread.currentThread().getPriority());//默认的5

        t1.setPriority(1);
        t2.setPriority(10);
        //权重越高只是代表抢到cpu先执行完毕的概率越高，并不是代表一定

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

    }

4.5 setDaemon 守护线程(备胎线程)

细节:

当其他的非守护线程执行完毕之后，守护线程会陆续结束(不是直接结束)

通俗易懂：

当女神进程结束了，那么备胎也没有存在的必要了

应用场景：
比如QQ聊天时，聊天窗口：线程1，传输文件：线程2
当聊天窗口关闭之后，那么正在传输的文件就断开了，也就是线程2这个备胎就没有存在的必要了

MyThread1类：
public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

MyThread2类：
public class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

测试类：
public class Test1 {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("备胎");

        t2.setDaemon(true);

        t1.start();//非守护线程
        t2.start();//守护线程

    }
}

4.6 yield 礼让线程

礼让线程 = 出让线程

场景：
两个线程同时启动，线程的执行是随机性的，有可能是你一次我一次这样的交替执行，也有可能是一个刷一下执行很多个、再刷一下执行另外一个

如果不想这样子，想要线程的执行均匀一点，此时就可以用到yield的出让线程
一个打印完成之后，就会出让其当前cpu的执行权，那么此时又回到了重新抢夺的时候，可以显得均匀一点

只是尽可能地均匀，不是绝对，在以后的代码中这个方法很少会用到

MyThread类：
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

测试类：
   public static void main(String[] args) {
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        mt1.setName("飞机");
        mt2.setName("坦克");

        mt1.start();
        mt2.start();

    }

4.7 join 插队线程

小细节:join要放在start的后面才能插队
这个方法在以后用的也不多

MyThread类：
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

测试类：
    public static void main(String[] args) {
        MyThread mt1 = new MyThread();
        mt1.setName("麻瓜");
        mt1.start();

        //执行在main线程当中的
        for (int i = 0; i < 5; i++) {
            System.out.println("main线程"+i);
        }
    }

现在的需求：把麻瓜这个线程插入到main线程之前，等到麻瓜执行完了，这个main线程再执行

   public static void main(String[] args) throws InterruptedException {
        MyThread mt1 = new MyThread();
        mt1.setName("麻瓜");
        mt1.start();

        mt1.join();

        //z执行在main线程当中的
        for (int i = 0; i < 5; i++) {
            System.out.println("main线程"+i);
        }
    }

5. 线程的生命周期

创建线程对象(新建状态,小宝子)----start()----->有执行资格但是没有执行权(就绪状态,不停的抢CPU,)------抢到CPU的执行权------>有执行资格并且有执行权(运行状态,线程运行代码)-----run（）执行完毕---->线程死亡，变成垃圾（死亡状态）

如果被其他线程抢走CPU的执行权，那么运行状态的线程会重新返回就绪状态（有执行资格没有执行权）

如果在运行状态时遇到了sleep（）或者其他的阻塞式方法，就会变成没有执行资格也没有执行权的阻塞状态（等着呗），阻塞状态结束会重新变成就绪状态去抢进程

不会立马执行，会有一个抢夺的过程

6. 线程的安全问题

当多个线程操作同一个数据的时候，会出现问题

可见窗口1、2、3，它们的卖票都是独立的，都卖同一张，这不是我想要的。需求：卖出票的总数要为100才行

那么要这么办？

加个statci给ticket票，表示所有类的对象都共享。但是这个方案，也有些问题，有的会出现重复的票和超出范围的票

MyThread类：
public class MyThread extends Thread{
    static int ticket = 0;
    @Override
    public void run() {
        while(true){
            if(ticket<100){
                try {
                    Thread.sleep(500);//这个sleep是没有异常抛出的，只能try
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket++;
                System.out.println(getName()+"正在卖第"+ticket+"张票");
            }else {
                break;
            }
        }
    }
}

测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();

        mt1.setName("窗口1");
        mt2.setName("窗口2");
        mt3.setName("窗口3");

        mt1.start();
        mt2.start();
        mt3.start();

    }
}

这些问题要这么解决呢？
把操作共享数据的代码锁起来

6.1 同步代码块

买票引发的安全问题：

• 原因1：线程在执行代码的时候，CPU的执行全随时有可能会被其他线程抢走 线程执行时，有随机性

在自增的时候还没来得及打印，cpu的执行权就被线程2抢走了，又到了线程3依次类推，导致自增，然后同时打印出来，就为卖的是同一张票了

• 原因2：线程执行的时候有随机性，CPU的执行权有可能会被其他线程抢走
  
  

解决方案：

所以要把操作共享数据的代码锁起来——synchronized（锁对象）{ }

特点一：锁默认时打开的，有一个线程进去了，锁自动关闭
特点二：里面的代码全部执行完毕，线程出来，锁自动打开

测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();

        mt1.setName("窗口1");
        mt2.setName("窗口2");
        mt3.setName("窗口3");

        mt1.start();
        mt2.start();
        mt3.start();

    }
}

MyThread类：
public class MyThread extends Thread{
    static int ticket = 0;

    //锁对象，一定要是唯一的
    static Object o = new Object();
    @Override
    public void run() {
        while(true){
            //同步代码块
                synchronized (o){
                    if(ticket<100){
                        try {
                            Thread.sleep(1);//这个sleep是没有异常抛出的，只能try
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticket++;
                        System.out.println(getName()+"正在卖第"+ticket+"张票");
                    }else {
                        break;
                    }
                }
        }
    }
}

这个有时候会只有一个线程就卖光所有票了，是抢夺cpu的概率问题

有关同步代码快的小细节：

1. synchronized不能写在循环外面
   不然就是一个线程把全部的票卖完了才出来

2. synchronized的锁对象一定是唯一的
   一般的锁会写成当前类的字节码文件
   

就不要用this作为锁，比如：

应该使用当前类的字节码文件对象

6.2 同步方法

选中想要的代码，一键变成构造方法ctl+alt+m

MyRunnable类：
public class MyRunnable implements Runnable{
    int ticket = 0;
    @Override
    public void run() {
        //1.循环
        while(true){
            //2.同步代码块（同步方法）
            if (method()) break;
        }
    }

    private boolean method() {
        synchronized (MyRunnable.class){
            //3.判断共享数据是否到了末尾
            if(ticket==100){
                return true;
            }else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket++;
                System.out.println(Thread.currentThread().getName()+"在卖第"+ticket+"张票");
            }
        }
        return false;
    }
}

测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

字符串在拼接的时候除了StringBuilder，还有stringBuffer，其区别：
它们的方法都是一模一样的

• 当不需要考虑多线程，采用单线程时，用StringBuilder。当时StringBuilder的实例用于多个线程是不安全的，不能同步
• 当是多线程环境下，需要考虑到数据安全就选择stringBuffer。stringBuffer的每一个成员方法上都有着sychronized

6.3 Lock 锁

以上面的同步代码块为例，当有线程进来执行代码之后，上头的锁是会自动去关闭的；当线程出来之后，锁又会自动打卡。所有这里锁的开关，没办法自行控制

那么有什么办法去解决这个问题呢？

案例：
1.

这样写的话就会打印很多的票，有很多都超出范围，也有很多的重复票

为什么出现这种情况呢？
因为如果所定义的MyThread被创建了很多次，那么久势必会造成这里的lock锁，它有多个对象。
解决方案：

• 加个static关键字给锁就行
  

运行完之后，重复的票和超出范围的票无了，但是新的问题又出现了——程序没有停

为什么呢？
分析：

1. 假设刚开始是线程1抢到了cpu的执行权，执行到循环执行到锁lock时，相当于把锁给锁上了
2. 解决进入判断睡觉，睡觉的时候cpu的执行权会被其他线程2、或3给抢走，但是它抢走之后又重新执行到了lock的位置时，这个锁本来就被线程1给锁上了，就无法再次获取锁的对象，被关在外面了
3. 到线程1醒来之后，继续往下走，释放锁，线程1回到上面又与线程2、3抢夺cpu执行权
4. 假设还是线程1拿到了cpu的执行权，等到ticket=100时，跳出循环外面，却没有执行循环里面的unlock方法（即没有打开锁）
5. 所以这样就导致了线程1结束了，它却拿着锁对象出去了，没有把锁打开。因此线程2、3就一直停止在lock的地方，程序就不会停止

解决方案：

采用try等执行，把lock.unlock方法写在finally一定会执行当中

代码：

MyRunnable类：
public class MyRunnable implements Runnable{
    int ticket = 0;
    static Lock lock = new ReentrantLock();
    @Override
    public void run() {
        //1.循环
        while(true){
            //2.同步代码块（同步方法）
//            synchronized (MyRunnable.class){
            lock.lock();
                //3.判断共享数据是否到了末尾
            try {
                if(ticket==100){
                    break;
                }else {
                    Thread.sleep(100);
                    ticket++;
                    System.out.println(Thread.currentThread().getName()+"在卖第"+ticket+"张票");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
//            }
        }
    }
}

测试类：
   public static void main(String[] args) throws InterruptedException {
        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

6.4 理解死锁（一个错误）

在程序当中出现了锁的嵌套，外面一个锁，里面一个锁，这就形成了死锁

比喻：
线程a拿着a锁，线程b拿着b锁，它们都在等着对方先释放锁，所以在这个时候程序就会卡死

案例：

public class MyThread extends Thread {
//定义了两把锁
    static Object obja = new Object();
    static Object objb = new Object();
    @Override
    public void run(){
        while(true){
        if ("线程A".equals(getName())){
            synchronized (obja){
                System.out.println("线程A拿到了A锁，准备拿B锁");
                synchronized (objb){
                    System.out.println("线程A拿到了B锁，顺利执行玩一轮");
                }
            }
        }else if ("线程B".equals(getName())){
            synchronized (objb){
                System.out.println("线程B拿到了B锁，准备拿A锁");
                synchronized (obja){
                    System.out.println("线程B拿到了A锁，顺利执行玩一轮");
                }
            }
        }
        }
    }
}

程序卡死

总的来说：

以后设置锁的时候，千万不用让锁进行嵌套

7. 等待唤醒机制（生产者和消费者）

一条线程负责生产数据，另一条线程负责生产数据

比方：
桌子上没吃的就是厨师去烧菜

理想状态就是先是厨师抢到CPU执行权，做了一碗吃的，然后吃货来吃，吃货吃一碗，厨师做一碗

两种情况可能会出现:

1.消费者等待 一开始不是厨师抢到执行权而是吃货抢到，桌子上没东西（桌子不能吃），所以吃货只能等待，那么执行权就会被厨师抢到，做完以后厨师会唤醒在等待的吃货去吃
消费者：

• 1、判断桌子上是否有食物
• 2、如果没有就等待

生产者：

• 1、制作食物
• 2、把食物放在桌子上
• 3、叫醒等待的消费者开吃
  

2.生产者等待 第一时间是厨师抢到CPU执行权，然后做好吃的。 第二次还是厨师抢到CPU的执行权，因为桌子上有吃的，所以不会去做吃的，会”喊一嗓子“，进入等待状态，等待吃货抢到CPU执行权，吃掉桌子上的东西以后才会继续让厨师运作起来
消费者：

• 1、判断桌子上是否有食物
• 2、如果没有就等待
• 3、如果有就开吃
• 4、吃完之后，唤醒厨师继续做

生产者：

• 1、判断桌子上是否有食物
• 2、有：等待
• 3、没有：制作食物
• 4、把食物放在桌子上
• 5、叫醒等待的消费者开吃
  

常见方法：

7.1 消费者代码实现

Desk桌子类：
public class Desk {
    /*
    桌子的作用：控制生产者和消费者的执行
     */
    //判断是否有面条
    //0：没有面条    1：有面条
    public static int foodFlag = 0;

    //总个数
    public static int count =10;

    //锁对象
    public static Object lock = new Object();
}

Foodie消费者类：
public class Foodie extends Thread{

    @Override
    public void run() {
    /*线程四步套路：
    1.循环
    2.同步代码块
    3.判断共享数据是否到了末尾（到了末尾的情况）
    4.没有到达末尾的情况，执行核心逻辑
     */
        while (true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    //代表面条总个数没有了
                    //当消费者把我库存的10碗面条吃完了，线程就要停止
                    break;
                }else {
                    //先判断桌子上是否有面条
                    if(Desk.foodFlag==0){
                        //如果有，就等待
                        try {
                            Desk.lock.wait();
                            //等待的时候不能直接用wait
                            //让锁对象等待，就是让当前线程同锁对象进行绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else {
                        //有面条，把吃的总数-1
                        Desk.count--;
                        System.out.println("消费者在吃面条，还能吃"+Desk.count+"碗");

                        //吃完之后，唤醒厨师继续做
                        Desk.lock.notifyAll();

                        //然后修改桌子的状态，表示原本的那一碗吃完了
                        Desk.foodFlag = 0;
                    }
                }
            }
        }

    }
}

7.2 生产者代码实现

Cook类：
public class Cook extends Thread{
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else {
                    //厨师判断桌子上是否有食物
                    if(Desk.foodFlag==1){
                        //如果有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else {
                        //如果没有食物，厨师开做
                        System.out.println("厨师做了一碗面条");
                        //修改桌子上的食物状态
                        Desk.foodFlag=1;
                        //叫醒消费者开吃
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

测试类：
public class ThreadDemo {
    public static void main(String[] args) {
        //创建消费者和生产者线程对象
        Cook c = new Cook();
        Foodie f =new Foodie();

        //给线程设置名字
        c.setName("厨师");
        f.setName("吃货");

        c.start();
        f.start();
    }
}

7.3 阻塞队列实现等待唤醒机制

什么是阻塞队列？

就好比是连接生产者和消费者之间的管道

厨师做好面条之后就把其放到管道当中，而左边的消费者就可以从管道当中获取面条去吃，管道可以规定最多放多少面条。所以这个管道其实就是阻塞队列


需求：利用阻塞队列完成生产者和消费者（等待唤醒机制）的代码

细节：生产者和消费者必须使用同一个阻塞队列

Cook类：
public class Cook extends Thread{
    ArrayBlockingQueue<String> queue;//这次只定义不给值
    //需要在创建对象的时候才给值

    //创建对象的时候把其地址值给传递过来
    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;//传递过来之后再赋给成员变量这个队列就可以了
    }

    @Override
    public void run() {
        while(true){
            //不断的把面条放进阻塞队列当中
            //其put方法中底层有锁，不用再设置锁
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Foodie类：
public class Foodie extends Thread{
    ArrayBlockingQueue<String> queue;//这次只定义不给值
    //需要在创建对象的时候才给值

    //创建对象的时候把其地址值给传递过来
    public Foodie(ArrayBlockingQueue<String> queue) {
        this.queue = queue;//传递过来之后再赋给成员变量这个队列就可以了
    }

    @Override
    public void run() {
        while(true){
            //不断地从阻塞队列中获取面条
            //其take方法中底层有锁，不用再设置锁
            try {
                String food = queue.take();
                System.out.println("消费者吃了"+food);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类：
public class ThreadDemo {
    public static void main(String[] args) {
        //创建阻塞队列中的对象
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

        //创建线程，把阻塞队列传递过去
        Cook c = new Cook(queue);
        Foodie f = new Foodie(queue);

        c.start();
        f.start();
    }
}

这竟然出现了重复的，因为queue的put和take底层都有锁，而打印语句其实是定义在锁的外面，所以就会造成控制台当中数据的这种现象。但是它不会对共享数据造成任何影响

8. 线程的状态

java的虚拟机当中是没有定义运行状态的，理解时添加的

java当中真正定义的其实就是6种状态，是没有定义运行状态的
为什么呢？

当线程抢夺到cpu的执行权时，那么此时虚拟机就会把当前的线程交给操作系统去管理了，虚拟机不管这个，所以就没有定义运行状态
就好比买了不手机，手机坏了交出去微信，就不管了

9. 多线程综合练习

9.1 卖电影票

9.2 送礼品

9.3 打印奇数数字

9.4 抢红包

选用JDK17默认的SDK，才能使用nextDouble


不然报错：

MyThread类：
public class MyThread extends Thread{
   //共享数据
    //100块，分成了3个包
    static double money = 100;
    static int count = 3;
    //最小的中奖金额
    static final double MIN = 0.01;

    @Override
    public void run() {
        //同步代码块
        synchronized(MyThread.class){
            //判断，共享数据是否到了末尾，没有
            if(count==0){
                System.out.println(getName()+"没有抢到票");
            }else {
                //判断，到了末尾
                //定义一个变量，表示中奖的金额
                double prize = 0;
                if(count==1){
                    //表示此时是最后一个红包
                    //就无需随机，剩余所有的钱都是中奖金额
                    prize = money;
                }else {
                    //表示第一次，第二次 (要随机)
                    Random r = new Random();
                    //100 分成3个包
                    //要像到最夸张的情况，第一个红包：99.98 剩下分配0.01 .0.1
                    //100-（3-1）*0.01
                    double bounds = money - (count - 1) * MIN;
                    prize = r.nextDouble(bounds);//nextDouble是JDK17以上才有的
                    if(prize<MIN){
                        prize = MIN;
                    }
                }
                //从money中，去掉当前中奖的金额
                money = money - prize;
                //然后红包的个数-1
                count--;
                System.out.println(getName()+"抢到了"+prize+"元");

            }


        }
    }


}


测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();
        MyThread mt4 = new MyThread();
        MyThread mt5 = new MyThread();

        mt1.setName("麻瓜");
        mt2.setName("里皮");
        mt3.setName("AKM");
        mt4.setName("小老板");
        mt5.setName("愣头青");

        mt1.start();
        mt2.start();
        mt3.start();
        mt4.start();
        mt5.start();

    }
}

生活实际没有小数点后面这么多位：

public class MyThread extends Thread{
   //共享数据，利用BigDecimal精确运算到我想要的小数点
    //用double小数点太多
    //100块，分成了3个包
    static BigDecimal money = BigDecimal.valueOf(100.00);
    static int count = 3;
    //最小的中奖金额
    static final BigDecimal MIN = BigDecimal.valueOf(0.01);

    @Override
    public void run() {
        //同步代码块
        synchronized(MyThread.class){
            //判断，共享数据是否到了末尾，没有
            if(count==0){
                System.out.println(getName()+"没有抢到票");
            }else {
                //判断，到了末尾
                //定义一个变量，表示中奖的金额
                BigDecimal prize;
                if(count==1){
                    //表示此时是最后一个红包
                    //就无需随机，剩余所有的钱都是中奖金额
                    prize = money;
                }else {
                    //表示第一次，第二次 (要随机)
                    Random r = new Random();
                    //100 分成3个包
                    //要像到最夸张的情况，第一个红包：99.98 剩下分配0.01 .0.1
                    //100-（3-1）*0.01
                    double bounds = money.subtract(BigDecimal.valueOf(count-1).multiply(MIN)).doubleValue();
                    prize = BigDecimal.valueOf(r.nextDouble(bounds));//nextDouble是JDK17以上才有的

                }
                //设置抽中红包，小数点保留两位，四舍五入
                prize=prize.setScale(2, RoundingMode.HALF_UP);
                //从money中，去掉当前中奖的金额
                money = money.subtract(prize);
                //然后红包的个数-1
                count--;
                System.out.println(getName()+"抢到了"+prize+"元");

            }


        }
    }


}

9.5 抽奖箱抽奖

MyThread类：
public class MyThread extends Thread{
    //采用集合更方便，不重复元素
    ArrayList<Integer> list;
    //为了防止线程1、2等跑下面方法会重复添加元素进集合当中
    //可以在成员位置去定义一个构造方法，在创建对象的时候把集合传递过来，这样集合也是唯一的

    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        while(true){
            synchronized (MyThread.class){
                if(list.size()==0){//如果集合里的元素被删到没有了就结束
                    break;
                }else {
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    System.out.println(getName()+"又产生了"+prize+"的大奖");
                }
                //在锁的外面，让线程平均一点，如果写在锁的里面效果不明显
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        //创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);

        //创建线程
        MyThread mt1 = new MyThread(list);
        MyThread mt2 = new MyThread(list);

        mt1.setName("麻瓜");
        mt2.setName("愣头青");
        //抽奖
        mt1.start();
        mt2.start();

    }
}

9.6 多线程统计并求最大值

解法一：

public class MyThread extends Thread{
    //采用集合更方便，不重复元素
    ArrayList<Integer> list;
    //为了防止线程1、2等跑下面方法会重复添加元素进集合当中
    //可以在成员位置去定义一个构造方法，在创建对象的时候把集合传递过来，这样集合也是唯一的

    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    //将抽奖结果存入到一个容器当中
    static ArrayList<Integer> list1 = new ArrayList<>();
    static ArrayList<Integer> list2 = new ArrayList<>();

    @Override
    public void run() {
        while(true){
            synchronized (MyThread.class){
                if(list.size()==0){//如果集合里的元素被删到没有了就结束
                    if("抽奖箱1".equals(getName())){
                        System.out.println("抽奖箱1"+list1);
                    }else {
                        System.out.println("抽奖箱2"+list2);
                    }
                    break;
                }else {
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    if("抽奖箱1".equals(getName())){
                        list1.add(prize);
                    }else {
                        list2.add(prize);
                    }
                }
                //在锁的外面，让线程平均一点，如果写在锁的里面效果不明显
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

解法二：
如果要创建1000给线程的话，采用一的方案就非常麻烦

所以可以创建一个集合，每次线程进来都放进集合当中，将得奖放进集合当中，然后与获取名字+集合的形式打印出来即可

MyThread类：
public class MyThread extends Thread{
    //采用集合更方便，不重复元素
    ArrayList<Integer> list;
    //为了防止线程1、2等跑下面方法会重复添加元素进集合当中
    //可以在成员位置去定义一个构造方法，在创建对象的时候把集合传递过来，这样集合也是唯一的

    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    //将抽奖结果存入到一个容器当中
    static ArrayList<Integer> list1 = new ArrayList<>();
    static ArrayList<Integer> list2 = new ArrayList<>();

    @Override
    public void run() {
        ArrayList<Integer> boxList = new ArrayList<>();
        while(true){
            synchronized (MyThread.class){
                if(list.size()==0){//如果集合里的元素被删到没有了就结束
                    System.out.println(getName()+boxList);
                    break;
                }else {
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    boxList.add(prize);
                }
                //在锁的外面，让线程平均一点，如果写在锁的里面效果不明显
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        //创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);

        //创建线程
        MyThread mt1 = new MyThread(list);
        MyThread mt2 = new MyThread(list);

        mt1.setName("抽奖箱1");
        mt2.setName("抽奖箱2");
        //抽奖
        mt1.start();
        mt2.start();

    }
}

内存图解：


每个线程都有自己的集合互不干扰

9.7 多线程之间的比较

MyCallable类：
public class MyCallable implements Callable<Integer> {
    //采用集合更方便，不重复元素
    ArrayList<Integer> list;
    //为了防止线程1、2等跑下面方法会重复添加元素进集合当中
    //可以在成员位置去定义一个构造方法，在创建对象的时候把集合传递过来，这样集合也是唯一的

    public MyCallable(ArrayList<Integer> list) {
        this.list = list;
    }

    //将抽奖结果存入到一个容器当中
    static ArrayList<Integer> list1 = new ArrayList<>();
    static ArrayList<Integer> list2 = new ArrayList<>();


    @Override
    public Integer call() throws Exception {
        ArrayList<Integer> boxList = new ArrayList<>();
        while(true){
            synchronized (MyCallable.class){
                if(list.size()==0){//如果集合里的元素被删到没有了就结束
                    System.out.println(Thread.currentThread().getName()+boxList);
                    break;
                }else {
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    boxList.add(prize);
                }
            }
            Thread.sleep(100);
        }
        if(boxList.size()==0){
            return null;
        }else {
            return Collections.max(boxList);
        }
    }
}


测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);

        //创建多线程要运行的参数对象
        MyCallable mc = new MyCallable(list);

        //创建多线程运行结果的管理者对象
        FutureTask<Integer> ft1 = new FutureTask<>(mc);
        FutureTask<Integer> ft2 = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 =new Thread(ft1);
        Thread t2 = new Thread(ft2);

        //设置名字
        t1.setName("抽箱1");
        t2.setName("抽箱2");

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

        System.out.println(ft1.get());
        System.out.println(ft2.get());
    }
}

10. 线程池

以前写多线程的弊端
弊端1：用到线程的时候就创建
弊端2：用完之后线程消失
浪费了系统的资源

那么我们就要用一个容器去存放线程——线程池

线程池主要核心原理
1、创建一个池子，池子中是空的。
2、提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子，下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可
3、但是如果提交任务时，池子中没有空闲线程，也无法创建新的线程，任务就会排队等待。

特殊情况：

线程池代码实现：
在实际开发当中，线程池一般是不会关闭的，因为服务器是24小时运行的

线程池工具类：

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象

IDEA快捷改类名字——shift+F6
1.

 MyRunnable类：
public class MyRunnable implements Runnable{
    @Override
    public void run() {
//        for (int i = 0; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName()+"---");
//        }
    }
}

测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //1.获取线程池对象
        ExecutorService pool1 = Executors.newCachedThreadPool();

        //2.提交任务
        //每次提交之前都让main线程睡觉，目的就是让任务感觉执行完毕把线程还回去
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);

//        //3.销毁线程池
//        pool1.shutdown();
    }
}

2.

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

测试类：
public class Test1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //1.获取线程池对象
        ExecutorService pool1 = Executors.newFixedThreadPool(3);

        //2.提交任务
        //每次提交之前都让main线程睡觉，目的就是让任务感觉执行完毕把线程还回去
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);

//        //3.销毁线程池
//        pool1.shutdown();
    }
}

10.1 自定义线程池详细解析

饭店里招员工
来一个顾客临时找一个服务员，进行一对一服务
顾客走了，服务员也就辞退了
但是这个时候引进了正式员工
就算没有顾客，正式员工也不会被辞退
但是顾客过多时还是会引入临时员工进行帮忙

核心元素一：正式员工数量
核心元素二：餐厅最大员工数
核心元素三：临时员工空闲多长时间被辞退（值）
核心元素四：临时员工空闲多长时间被辞退（单位）
核心元素五：排队的客户
核心元素六：从哪里招人
核心元素七：当排队人数过多，超出顾客请下次再来（拒绝服务）

细节：
什么时候才会去创建临时线程?
核心线程都在忙，而且队伍已经排满了，才会去创建临时线程

任务在执行的时候，一定是按照提交的顺序来执行的吗？

不是，任务4、5、6还在排队呢，而后提交的7、8已经正在执行了

当线程满负荷时，如果还有其他线程就会触发拒绝策略，舍弃不要

10.2 自定义线程池的任务拒绝策略

    public static void main(String[] args) throws IOException {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
          3,//核心线程数量，能小于0
          6,//最大线程数，不能小于0，最大数量>=核心线程数量
          60,//允许空闲线程最大存活世界
                TimeUnit.SECONDS,//时间单位
                new ArrayBlockingQueue<>(3),//任务独立
                Executors.defaultThreadFactory(),//创建线程工厂
                new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略，为什么将其定义位内部类？
                //因为内部类是依赖于外部类而存在的，单独出现没有任何意义，而且内部类的本身又是一个独立的个体
        );
    }

关于拒绝策略是内部类
为什么将其定义位内部类？

因为内部类是依赖于外部类而存在的，单独出现没有任何意义，而且内部类的本身又是一个独立的个体

拒绝策略单独存在没有意义，只有在线程池中才有意义
就像心脏单独存在没有意义，只有在人体中才有意义

线程池小结
1、创建一个空的池子
2、有任务提交时，线程池会创建线程去执行任务，执行完毕归还线程

不断地提交任务，会有以下三个临界点：
1、当线程池满时，再提交任务就会排队
2、当核心线程满，队伍满时，会创建临时线程
3、当核心线程满，队伍满，临时线程满时，会触发任务拒绝策略

10.3 最大并行数

最大并行数和cpu有关
以4核8线程的为例：

4核就相当于cpu有4个大脑，在超线程技术的支持下，就能把原本的四个大脑虚拟成8个，这8个就是线程，最大并行数是8

向java虚拟机返回可用处理器的数目

    public static void main(String[] args) throws IOException {

        int count = Runtime.getRuntime().availableProcessors();
        System.out.println(count);
    }

my电脑线程数为16，故最大并行数就用16来进行计算

10.4 线程池多大合适

项目可以分成两种

1. CPU密集型运算（计算多，读取录入少）：

最大并行数+1（+1是为了万一前面有个线程出问题了，保证CPU的时钟周期不被浪费。说简单点就是后补，前面出问题，后面就要顶上去）
比如我的线程是16，那么线程池最大就是16+1=17

2. I/O密集型运算（读取录入多）：
   比如当执行业务计算的时候，此时会使用cpu的资源，但是当进行I/O操作的时候或者远程调用rpc操作操作、或者操作数据库的时候，这个时候cpu就闲置下来了。此时就可以利用多线程技术，把闲下来的时间给利用起来

公式：

最大并行数期望CPU利用率总共时间（CPU计算时间+等待时间）/CPU计算时间

那么cpu的计算时间和等待时间怎么获取呢？
可以用thread dump工具来测试

11. 多线程的额外拓展内容

面试的时候喜欢问该知识点