Java Day18

第一章 等带唤醒机制

1.1 线程间通信

• 概念：多个线程在处理同一个资源，但是处理动作却不相同。
• 为什么要处理线程间通信：多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望有规律执行，那么多个线程之间需要一些协调通信，以此来达到多线程共同操作一份数据。
• 如何保证线程间通信有效利用资源：多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用和操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段被称为——等待唤醒机制。

1.2 等待唤醒机制

• 什么是等待唤醒机制：这是多个线程间的一种协作机制。就是在一个线程进行规定的操作后，就进入等待状态（wait），等待其他线程执行完他们的指定代码后再将其唤醒（notify）；在有多个线程进行等待时，如果需要可以使用notifyAll来唤醒所有的等待线程。
• 等待唤醒的方法：
  • wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会竞争锁了，这是线程状态即WAITING，它还要等着别的线程执行一个特别的动作，也即是“通知”在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列中。
  • notify：则选取所通知对象的wait set中的一个线程释放。
  • notifyAll：释放所通知对象的wait set上的全部线程。
• 调用wait和notify方法需要注意的细节
  • wait方法与notify方法必须要由同一个锁对象调用。因为，对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  • wait方法与notify方法是属于Object类的方法的。因为，锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
  • wait方法与notify方法必须要在同步代码块或这同步函数中使用。因为：必须要通过锁对象调用这2个方法。

1.3 生产者与消费者问题

等待唤醒机制其实就是经典的生产者与消费者的问题，代码演示：

定义包子类：

/*
* 资源类：包子类
* 设置包子的属性：
*   皮
*   馅
*   包子的状态：有true，没有false
* */

public class Baozi {
    // 皮
    String pi;

    // 馅
    String xian;

    // 包子的状态：有true，没有false，设置初始值为false没有包子
    boolean flag = false;

}

定义吃货线程类：

/*
* 消费者类：是一个线程类，可以继承Thread
* 设置线程任务（run）：吃包子
* 对包子的状态进行判断：
* false：没有包子
*   吃货调用wait方法进入等待状态
* true有包子
*   吃货吃包子
*   吃货吃完包子
*   修改包子的状态为false
*   吃货唤醒包子铺线程，生产包子
* */

public class ChiHuo extends Thread {
    private Baozi bz;

    // 使用构造方法为包子变量赋值
    public ChiHuo(Baozi baozi) {
        this.bz = baozi;
    }

    // 设置线程任务：吃包子
    @Override
    public void run() {
        // 使用死循环让吃货一直吃包子
        while (true) {
            // 必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz) {
                // 对包子状态进行判断
                if (bz.flag == false) {
                    // 吃货调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 被唤醒之后执行的代码
                System.out.println("吃货正在吃：" + bz.pi + bz.xian + "的包子。");
                // 吃货吃完包子修改包子的状态
                bz.flag = false;
                // 唤醒包子铺线程
                bz.notify();
                System.out.println("吃货已经把：" + bz.pi + bz.xian + "的包子，吃完了，包子铺开始生产包子。");
                System.out.println("===============================================");
            }
        }

    }
}

定义包子铺线程类：

/*
* 生产者：是一个线程类，可以继承Thread
* 设置线程任务（run）：生产包子
* 对包子的状态进行判断：
*   true有包子
*   包子铺调用wait方法进入等待状态
*   false没有包子
*       包子铺生产包子
*       增加一些趣味性：交替生产两种包子
*           有两种状态
*       包子铺生产好了包子
*       修改包子的状态为true
*       唤醒吃货线程，让吃货线程吃包子
*
* 注意：
*   包子铺线程和包子线程关系-->通信（互斥）;
*   必须同时同步技术保证两个线程只能有一个在执行
*   锁对象必须保证唯一，可以使用包子对象作为锁对象
*   包子铺和出货两个类就需要把包子对象作为参数传递进来：
*       需要在成员位置创建一个包子变量
*       使用带参数的构造方法，为这个包子变量赋值
* */

public class BaoZiPu extends Thread {
    // 创建一个包子变量
    private Baozi bz;

    // 使用带参数的构造方法，为这个包子变量赋值
    public BaoZiPu(Baozi bz) {
        this.bz = bz;
    }

    // 设置线程任务：生产包子
    @Override
    public void run() {
        // 定义一个变量
        int count = 0;

        // 让包子铺一直生产包子
        while(true) {
            // 必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz) {
                // 对包子的状态进行判断：
                if (bz.flag == true) {
                    // 包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 被唤醒之后执行，包子铺生产包子
                // 增加一些趣味性，交替生产两种包子
                if (count % 2 == 0) {
                    // 生产薄皮三鲜馅包子
                    bz.pi = "薄皮";
                    bz.xian = "三鲜";
                } else {
                    // 生产冰皮牛肉大葱馅
                    bz.pi = "冰皮";
                    bz.xian = "牛肉大葱馅";
                }
                count++;
                System.out.println("包子铺正在生产：" + bz.pi + bz.xian + "包子");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 生产好包子
                // 修改包子的状态为true
                bz.flag = true;
                bz.notify();
                System.out.println("包子铺已经生产好了：" + bz.pi + bz.xian + "包子，吃货可以开吃了。" );
            }

        }


    }
}

定义测试类：

public class Demo01Main {
    public static void main(String[] args) {
        Baozi baozi = new Baozi();
        new BaoZiPu(baozi).start();
        new ChiHuo(baozi).start();
    }
}

第二章 线程池

2.1 线程池思想概述

• 线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁的创建线程对象的操作，无需反复创建线程而消耗过多的资源。
• 原理如下：

• 合理使用线程池可以带来三个好处：
  • 降低资源消耗，减少了床架和销毁线程的次数，每个工作线程都可以被重复使用，可执行多个任务。
  • 提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。
  • 提高线程的可管理性，可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下。

2.2 线程池的使用

java里面线程池的顶级接口，java.lang.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是：java.util.concurrent.ExecutorService。

Executor类中提供过了一些静态工厂，生成一些常用的线程池，Executors类中有个创建线程池的方法如下：

• public static ExecutorService newFixedThreadPool(int nThread)：返回线程池对象。（创建的是有界线程池，也就是池中的线程个数可以指定最大数值）
• public Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行。

使用线程池中线程对象的步骤：

• 创建线程池对象
• 创建Runnable接口子类对象。
• 提交Runnable接口子类对象。
• 关闭线程池（一般不做）

代码演示：

Runnable实现类代码：

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了一个新的进程执行。");
    }
}

定义测试类：

public class Demo01ThreadPool {
    public static void main(String[] args) {
        //使用线程池的工厂类Executors里边提供的静态方法newFixThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);

        // 调用ExcutorService中的方法submit，传递线程任务，开启线程，执行run方法
        // 线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程可以继续使用
        es.submit(new RunnableImpl());  // pool-1-thread-2创建了一个新的进程执行。
        es.submit(new RunnableImpl());  // pool-1-thread-1创建了一个新的进程执行。
        es.submit(new RunnableImpl());  // pool-1-thread-2创建了一个新的进程执行。

        // 调用Executor中的方法shutdown销毁线程池（不建议执行）
        es.shutdown();
        es.submit(new RunnableImpl());  // 抛出异常，线程池都没有了，就不能获取线程了

    }
}

第三章 Lambda表达式

3.1 函数式编程思想概述

函数式编程尽量忽略面向对象的复杂语法，强调做什么，而不是以什么形式做。只要能获取到结果，谁去做的，怎么做的都不重要，重视结果，不重视过程。

3.2 Lambda

使用匿名内部类实现Runnable接口，代码演示：

/*
* 使用实现Runnable接口的方式实现多线程程序
*
* */

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

        // 简化代码，使用匿名内部类来实现多线程程序
        Runnable run2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类创建了一个进程");
            }
        };
        new Thread(run2).start();

        // 继续简化代码
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名对象+匿名内部类创建了一个进程");
            }
        }).start();
    }

}

匿名内部类的好处和弊端：一方面，匿名内部类可以帮我们省去事项类的定义；另一方面，匿名内部类的语法太复杂了。同样的代码使用lambda就要更加简单，lambda格式如下：

(参数类型 参数名称) -> {代码语句}

格式说明：

• 小括号内的语法与传统参数列表一致：无参数留空，多个参数则用逗号分隔。
• ->是新引入的语法格式，代表指向动作。
• 大括号内的语法与传统方法要求基本一致。

3.3 练习

3.3.1 练习一

定义一个接口：

public interface Cook {
    public abstract void makeFood();
}

定义一个测试类：

/*
* 需求：
*   给定一个厨子接口Cook，内含唯一的抽象方法makeFood，且无参数，无返回值。
*   使用lambda的标准格式调用invokeCook方法，打印输出"我吃饭了"字样
*
* */

public class DemoMain {
    public static void main(String[] args) {
        invokeCook(() -> {
            System.out.println("吃饭了");
        });
    }

    private static void invokeCook(Cook cook) {
        cook.makeFood();
    }
}

3.3.2 Lambda的参数与返回值

需求：使用数组存储刀割Person对象，对数组中的Person对象只用Arrays的sort方法通过年龄进行升序操作。

定义一个Person类：

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

定义一个测试类：

/*
* lambda表达式有参数有返回值的练习：
* 需求：
*   使用数组存储刀割Person对象
*   对数组中的Person对爱哪个使用Array的sort方法通过年龄进行升序排序
*
* */

import java.util.Arrays;
import java.util.Comparator;

public class Demo01Arrays {
    public static void main(String[] args) {
        // 使用数组存储多个Person对象
        Person[] arr = {
                new Person("aaa",10),
                new Person("bbb", 29),
                new Person("ccc", 14)
        };

        // 对数组中的Person对爱哪个使用Array的sort方法通过年龄进行升序排序
//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });

        // 使用lambda表达式
        Arrays.sort(arr, (Person o1, Person o2) -> {
            return o1.getAge() - o2.getAge();
        });

        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

3.4 lambda省略格式

• 省略规则：
  • 小括号内参数的类型可以省略。
  • 如果小括号内有且仅有一个参数，则小括号可以省略。
  • 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号，return关键字及语句分号，要省一起省。

代码演示：

定义一个接口：

public interface Calculator {
    int calc(int a, int b);
}

定义一个测试类：

public class DemoInvokeCalc {
    public static void main(String[] args) {
        // 原格式
        invokeCalc(120, 130, (int a, int b) -> {
            return a + b;
        });

        // 省略优化
        invokeCalc(120, 250, (a, b) -> a+b);
    }
    private static void invokeCalc(int a, int b, Calculator calculator) {
        int result = calculator.calc(a, b);
        System.out.println("结果是：" + result);
    }
}

3.5 Lambda使用前提

• 使用Lambda必须具有接口，并且要求接口中有且仅有一个抽象方法，有且仅有一个抽象方法的接口又被称为：函数式接口。
• 使用Lambda必须具有上下文推断，也就是方法的参数或者局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。