线程池、lambda表达式

1. 等待唤醒机制

线程间通信

概念：多个线程在处理同一个资源，但是的处理的动作（线程的任务）却不相同。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源的，线程A与线程B处理动作，一个是生产，一个是消费，那么线程A和线程B之间就存在线程通信问题

为什么要处理线程间通信:

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或者操作。就是多个线程在操作同一份数据时，避免对同意共享变量的争夺。也就是我们需要通过一定手段使各个线程能有效利用资源。而这种手段即–等待唤醒机制

等待与唤醒机制

什么是等待唤醒机制

这是个多线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争，比如去争夺锁，但是这并不是故事的全部，线程间也有协作机制。就好比在公司里面你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作完成某些任务

就是在一个线程进行了规定操作后，就进入等待状态（wait()），等待其他线程执行完他们的执行代码过后再将其唤醒（notify()）；在有多个线程进行等待时，如果需要，可以使用notify()来唤醒所有的等待线程。wait/notify就是线程间的一种协作机制。

等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题，使用到的3个方法的含义如下：

• wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁了，这时的线程的状态即是WAITING。它还要等着别的线程执行一个特别的动作，也即是**通知（notify）**在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列（ready queue）中
• notify：选取所通知对象的wait set中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
• notifyAll：释放所通知对象的wait set上的全部线程

注意

哪怕只通知了一个等待的线程，被通知线程也不能立即恢复，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其他线程的竞争），成功后才能在当初调用wait方法之后的地方恢复执行。

总结如下：

• 如果能获取锁，线程就从WAITING状态变成RUNNABLE状态；
• 否则，从wait set出来，又进入entry set，线程就从WAITING状态又变成BLOCKED状态

调用wait和notify方法需要注意的细节

• wait方法和notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程
• wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的
• wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须通过锁对象调用这两个方法。

生产者与消费者问题

package demo04;
/*
    资源类：包子类
    设置包子的属性
        皮
        馅
        包子的状态：由 true 没有 flase
 */
public class BaoZi {

    String pi;

    String xian;

    boolean flag = false;

}

           

package demo04;
/*
    生产者（包子铺）类：是一个线程类，可以选择Thread
    设置线程任务（run）：生产包子
    对包子的状态进行判断
    true：有包子
        包子调用wait方法进入等待状态
     false：没有包子
        包子铺产生包子
        增加一些趣味性：交替产生两种包子
            有两种状态（i%2==0）
        包子铺产生好了包子
        修改包子的状态为true
        唤醒吃货线程，让吃货线程吃包子

     注意：
        包子铺线程和吃货线程关系--》通信（互斥）
        必须同时同步技术保证两个线程只有一个在执行
        锁对象必须保证唯一，可以使用包子对象作为锁对象
            包子铺类和吃货类就需要把包子作为参数传递进来作为参数
                1.需要在成员位置创建又给包子变量
                2.使用带参构造方法，为这个包子变量赋值
 */
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){
                    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(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                bz.flag = true;

                bz.notify();
                System.out.println("包子铺已经生产好了:"+bz.pi+bz.xian+"包子，吃货可以开始吃了");


            }
        }

    }
}

           

package demo04;
/*
    测试类：
    包含main方法，程序执行的入口，启动执行
    创建包子对象；
    创建包子铺线程，开启，生产包子；
    创建吃货线程，开启，吃包子；
 */
public class Demo {
    public static void main(String[] args) {
        BaoZi bz = new BaoZi();

        new BaoZiPu(bz).start();

        new ChiHuo(bz).start();
    }
}

           

package demo04;
/*
    消费者（吃货）类：是一个线程类，可以继承Thread
    设置线程任务（run）：吃包子
    对包子的状态进行判断
    false：没有包子
        吃货调用wait方法进入等待状态
    true：有包子
        吃货吃包子
        吃货吃完包子
        修改包子的状态为false没有
        吃货唤醒包子铺线程，生产包子
 */
public class ChiHuo extends Thread{
    //1.需要在成员位置创建一个包子变量
    private BaoZi bz;

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

    //3.设置线程任务（run）：吃包子
    @Override
    public void run() {
        //使用死循环，让吃货一直吃包子
        while(true){
            //必须使用同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子的状态进行判断
                if (bz.flag==false){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒以后执行的代码，吃包子
                System.out.println("吃货正在吃"+bz.pi+bz.xian+"的包子");
                //吃货吃完包子修改包子的状态为false
                bz.flag = false;
                //吃货唤醒包子铺，生产包子
                bz.notify();
                System.out.println("吃货已经把："+bz.pi+bz.xian+"的包子吃完了，包子铺开始生产包子");
                System.out.println("----------------------------------");
            }
        }
    }
}

           

2. 线程池

package demo05;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
    线程池：JDK1.5之后提供的
    java.utils.concurrent.Executors：线程池的工厂类，用来生成线程池
    Executors 类中的静态方法：
        static ExecutorService newFixedThreadPool(int nThread) 创建一个可重用固定线程数的线程池
        参数：
            int nThreads:创建线程池中包含的线程数量
        返回值：
            ExecutorService接口，返回的是ExecutorService接口的实现类对象，我么可以使用ExecutorService接口接收（面向接口编程（不考虑实现类是谁，直接接收））
     java.util.concurrent.ExecutorService:线程池接口
        用来从线程池获取线程，调用start方法，执行线程任务
            submit(Runnable task)提交一个Runnable任务用于执行
        关闭/销毁线程池的方法
            void shutdown()
     线程池的使用步骤：
        1.使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
        3.调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
        4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）
 */
public class Demo01ThreadPool {
    public static void main(String[] args) {
        //1.使用线程池的工厂类Executor里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());

    }

}

           

package demo05;

import demo03.RunnableImp1;

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

           

3.Lambda表达式

面向对象的思想：做一件事，找一个能解决这个事情的对象，调用对象的方法，完成事情。

函数式编程思想：只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程。

package demo05;

public class Demo01Runnable {
    public static void main(String[] args) {
        //使用匿名内部类的方式，实现多线程
        new Thread(new RunnableImpl(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        }).start();

        //使用lambda表达式，实现多线程
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"新线程创建了");
        }).start();
    }
}

           

匿名内部类的好处与弊端

一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法–确实太复杂了

package demo05;

public class Demo01Runnable {
    public static void main(String[] args) {
        //使用匿名内部类的方式，实现多线程
        new Thread(new RunnableImpl(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        }).start();

        //使用lambda表达式，实现多线程
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"新线程创建了");
        }).start();
    }
}

           

练习

package demo05;

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

/*
    Lambda表达式有参数有返回值的练习
    需求：
        使用数组存储多个Person对象
        对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
 */
public class Demo01Arrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr = {
                new Person("柳岩",38),
                new Person("迪丽热巴",18),
                new Person("古力娜扎",19)
        };
        //对数组中的Person对象使用Arrays的sort方法通过年龄进行升序（前边-后边）排序
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        //遍历数组
        for (Person person : arr) {
            System.out.println(person);

        }

        //使用Lambda表达式，简化匿名内部类
        Arrays.sort(arr,(Person o1,Person o2)->{
            return o1.getAge()-o2.getAge();
        });

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


    }
}

           

package demo05;

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

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

    public Person() {
    }

    public String getName() {
        return name;
    }

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

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

    public int getAge() {
        return age;
    }

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

           

更简洁的Lambda表达式

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

• 使用Lambda必须有接口，且要求接口中有且仅有一个抽象方法

  无论是JDK内置的Runnable、Comparator接口还是自定义接口，只有当接口中的抽象方法存在且唯一时，才可以用Lambda。

• 使用Lambda必须有上下文推断

  也就是方法参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

  备注：有且仅有一个抽象方法的接口，称为函数式接口

package demo05;
/*
    Lambda表达式：是可推导，可以省略
    凡是根据上下文推导出来的内容，都可以省略书写
    可以省略的内容：
        1.（参数列表）：括号中参数列表的数据类型，可以省略不写
        2.（参数列表）：括号中的参数如果只有一个，那么类型和()都可以省略
        3.{一些代码}：如果{}中的代码只有一行，无论是否有返回值，都可以省略（{} return 分号）
            注意：要省略{}，return，分号必须一起省略
         */
public class Demo01ArrayList {
    public static void main(String[] args) {
        //使用匿名内部类的方式，实现多线程
        new Thread(new RunnableImpl(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        }).start();

        //使用lambda表达式，实现多线程
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"新线程创建了");
        }).start();

        //优化省略Lambda
        new Thread(()->System.out.println(Thread.currentThread().getName()+"新线程创建了")
        ).start();
    }
}