Java【线程池、Lambda表达式】

见pdf

等待唤醒机制

wait和notify

第二章 线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间。
容器->集合

java.util.concurrent.Executor

线程池:JDK1.5之后提供的
   java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
   Executors类中的静态方法:
       static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
       参数:
           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.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
        es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
        //线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
        es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
        es.submit(new RunnableImpl());//pool-1-thread-2创建了一个新的线程执行

        //4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
        es.shutdown();

        es.submit(new RunnableImpl());//抛异常,线程池都没有了,就不能获取线程了
    }

}

第三章 lamada表达式

1、Runnable

实现多线程程序

public class Demo01Runnable {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类
        Thread t = new Thread(run);
        //调用start方法开启新线程,执行run方法
        t.start();

        //简化代码,使用匿名内部类,实现多线程程序
        Runnable r = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" 新线程创建了");
            }
        };
        new Thread(r).start();

        //简化代码
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" 新线程创建了");
            }
        }).start();
    }
}

似乎只有方法体才是关键

目的只有run方法

2、转换编程思想

将 run 方法体内的代码传递给 Thread 类知晓。
2014年3月Oracle所发布的Java 8（JDK 1.8）中，加入了Lambda表达 式的重量级新特性，为我们打开了新世界的大门。

函数式编程

留一个小括号（）->一些代码

new Thread(() ‐> System.out.println("多线程任务执行！")).start(); // 启动线程

（）接口中抽象方法的参数列表

3、

对匿名内部类的代替

package com.itheima.demo04.Lambda;
/*
    需求:
        给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
        使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样
 */
public class Demo01Cook {
    public static void main(String[] args) {
//        调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });
//        使用Lambda表达式,简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("吃饭了");
        });

        //优化省略Lambda
        invokeCook(()-> System.out.println("吃饭了"));
    }

    //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

4、排序

lamada表达式

方法有参数就写参数，()->是实现类方法的体现

        Arrays.sort(arr,(Person o1, Person o2)->{
            return o1.getAge()-o2.getAge();
        });

        //优化省略Lambda
        Arrays.sort(arr,(o1, o2)->o1.getAge()-o2.getAge());

        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }

5、练习

invokeCalu(120,130,(int a,int b)->System.out.println("isheudi"));

是对匿名内部类的简化的重要操作。

6、还可以省略

Lambda表达式:是可推导,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:
    1.(参数列表):括号中参数列表的数据类型,可以省略不写
    2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
    3.{一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
        注意:要省略{},return,分号必须一起省略

一个参数可以省略参数

new Thread(()->System.out.println(Thread.currentThread().getName()+" 新线程创建了")).start();

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

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