【Java07】异常与多线程_java 异常导致多线程-优快云博客

本文链接：https://blog.youkuaiyun.com/nuts66/article/details/118994875

文章目录

01 异常、线程
02 线程、同步
03 线程池、Lambda表达式

01 异常、线程

1.1 异常介绍

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行。

异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Throwable体系：

Error:严重错误Error，无法通过处理的错误，只能事先避免。
Exception:表示异常，异常产生后程序员可以通过修改代码的方式纠正，使程序继续运行，是必须要处理的。

异常分类

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常。

编译时期异常:在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
运行时期异常:RuntimeException。在运行时期,检查异常。在编译时期,运行异常不会被编译器检测(不报错)。(如数学异常)

异常的分类，如下图：

在这里插入图片描述

异常的产生过程

下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

工具类

public class ArrayTools {
    // 对给定的数组通过给定的角标获取元素。
    public static int getElement(int[] arr, int index) {
        int element = arr[index];
        return element;
    }
}

测试类

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = { 34, 12, 67 };
        intnum = ArrayTools.getElement(arr, 4)
        System.out.println("num=" + num);
        System.out.println("over");
    }
}

上述程序执行过程图解：

在这里插入图片描述

1.2 异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

使用格式，例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

举个例子，代码如下：

public class ThrowDemo {
    public static void main(String[] args) {
        //创建一个数组 
        int[] arr = {2,4,52,2};
        //根据索引找对应的元素 
        int index = 4;
        int element = getElement(arr, index);

        System.out.println(element);
        System.out.println("over");
    }

    public static int getElement(int[] arr,int index){ 
       	//判断  索引是否越界
        if(index<0 || index>arr.length-1){
             /*
             判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。
             这时就会结束当前方法的执行，并将异常告知给调用者。
              */
             throw new ArrayIndexOutOfBoundsException("当前角标超出了数组的范围哦~~");
        }
        int element = arr[index];
        return element;
    }
}

注意：

如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。

然后对于调用者来说，一种是进行捕获处理，另一种就是继续将问题声明出去，使用throws声明处理。

Objects非空判断

自JDK7新增java.util.Objects类，Objects类由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作。

public static <T> T requireNonNull(T obj):检查指定对象引用不是null，如果是null，则抛出空指针异常。

查看源码发现这里对为null的进行了抛出异常操作：

public static <T> T requireNonNull(T obj) {
    if (obj == null)
      	throw new NullPointerException();
    return obj;
}

声明异常throws

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)。

代码演示：

public class ThrowsDemo {
    public static void main(String[] args) throws FileNotFoundException {
        read("a.txt");
    }

    // 如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            throw new FileNotFoundException("文件不存在");
        }
    }
}

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class ThrowsDemo2 {
    public static void main(String[] args) throws IOException {
        read("a.txt");
    }

    public static void read(String path)throws FileNotFoundException, IOException {
        if (!path.equals("a.txt")) {
            throw new FileNotFoundException("文件不存在");
        }
        if (!path.equals("b.txt")) {
            throw new IOException();
        }
    }
}

捕获异常try…catch

try-catch的方式就是捕获异常。

捕获异常：Java中有针对性的语句对异常进行捕获，可以对出现的异常进行指定方式的处理。

try:该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

演示如下：

public class TryCatchDemo {
    public static void main(String[] args) {
        try {
            read("b.txt");
        } catch (FileNotFoundException e) {
          	//try中抛出的是什么异常，在括号中就定义什么异常类型
            System.out.println(e);
        }
        
        System.out.println("over");
    }
    /*
     *
     * 我们 当前的这个方法中 有异常  有编译期异常
     */
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {
            throw new FileNotFoundException("文件不存在");
        }
    }
}

如何获取异常信息：

Throwable类中定义了一些查看方法:

public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public String getMessage():获取发生异常的原因。

提示给用户看,就提示错误原因。

finally 代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

比如，当打开了一个关联文件的资源，最后程序不管结果如何，都需要把这个资源关闭掉。

finally代码参考如下：

public class TryCatchDemo4 {
    public static void main(String[] args) {
        try {
            read("b.txt");
            System.out.println("上面的代码有异常，这一行代码就执行不到");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管程序怎样，这里都将会被执行。");
        }
        
        System.out.println("over");
    }
    
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {
            throw new FileNotFoundException("文件不存在");
        }
    }
    
}

异常注意事项

多个异常使用捕获又该如何处理呢？

多个异常分别处理。
多个异常一次捕获，多次处理。
多个异常一次捕获一次处理。

一般我们是使用一次捕获多次处理方式，格式如下：

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
不要在finally中写return语句，如果finally中有return,永远返回finally中的结果，应该避免该情况发生。
父类方法抛出了多个异常,子类重写父类该方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。

1.3 自定义异常

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

异常类如何定义:

自定义一个编译期异常: 自定义类并继承于java.lang.Exception。
自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException。

自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个登陆异常类RegisterException：

// 业务逻辑异常
public class RegisterException extends Exception {
    /**
     * 空参构造
     */
    public RegisterException() {
    }

    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

public class Demo {
    // 模拟数据库中已存在账号
    private static String[] names = {"bill","hill","jill"};
   
    public static void main(String[] args) {     
        //调用方法
        try{
              // 可能出现异常的代码
            checkUsername("nill");
            System.out.println("注册成功");//如果没有异常就是注册成功
        }catch(RegisterException e){
            //处理异常
            e.printStackTrace();
        }
    }

    //判断当前注册账号是否存在
    //因为是编译期异常，又想调用者去处理 所以声明该异常
     public static boolean checkUsername(String uname) throws RegisterException {
        for (String name : names) {
            if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new RegisterException(name+"已经被注册了！");
            }
        }
        return true;
    }
}

1.4 多线程

并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

并行与并发图解：

在这里插入图片描述

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

进程图解

在这里插入图片描述

线程图解

在这里插入图片描述

线程调度:

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

多线程原理

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

代码如下：

自定义线程类：

public class MyThread extends Thread{ 
    /** 利用继承中的特点 * 将线程名称传递 进行设置 */ 
    public MyThread(String name){ 
        super(name); 
    }
    
    /** 重写run方法 * 定义线程要执行的代码 */ 
    public void run(){ 
        for (int i = 0; i < 20; i++) {
            //getName()方法 来自父亲 
            System.out.println(getName()+i); 
        } 
    } 
}

测试类：

public class Demo01 {
	public static void main(String[] args) {
		System.out.println("这里是main线程"); 
        MyThread mt = new MyThread("小强"); 
        mt.start();
        //开启了一个新的线程 
        for (int i = 0; i < 20; i++) { 
            System.out.println("旺财:"+i); 
        }
	}
}

流程图：

在这里插入图片描述

多线程执行时，在栈内存中，其实每个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

在这里插入图片描述

02 线程、同步

2.1 创建线程

Thread类

通过继承承Thread类的方式，我们可以创建线程，API中该类中定义了有关线程的一些方法，具体如下：

构造方法：

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

Runnable接口

另一种更常用的方法是实现 java.lang.Runnable接口。

步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

代码如下：

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

测试类：

public class Demo { 
    public static void main(String[] args) { 
        //创建自定义类对象 线程任务对象 
        MyRunnable mr = new MyRunnable(); 
        //创建线程对象 
        Thread t = new Thread(mr, "迪迦"); 
        t.start(); 
        for (int i = 0; i < 20; i++) { 
            System.out.println("哥尔赞 " + i); 
        } 
    } 
}

使用匿名内部类的方式创建线程：

public class RunnableInnerDemo {
    public static void main(String[] args) {
		Runnable r=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("拿瓦"+" "+i);
                }
            }
        };
        new Thread(r).start();
        for (int i = 0; i < 20; i++) {
            System.out.println("驮拏多"+" "+i);
        }
    }
}

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

Thread和Runnable的区别

实现Runnable接口比继承Thread类所具有的优势：

避免了java中单继承的局限性。一个类只能继承一个类，类继承了Thread类就不能继承其他的类，实现了Runnable接口，还可以继承其他的类，实现其他的接口。
增强了程序的扩展性，降低了程序的耦合性（解耦）。实现Runnable接口的方式，把设置线程任务和开启线程任务进行了分离（解耦）。实现类中，重写了run方法：用来设置线程任务，创建Thread类对象，调用start方法：用来开启新线程。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是在操作系统中启动了一个进程。

2.2 线程安全问题

我们通过一个案例，演示线程的安全问题：

模拟票：

public class Ticket implements Runnable { 
    private int ticket = 100; 
   
    /** 执行卖票操作 */ 
    @Override public void run() { //每个窗口卖票的操作 
        //窗口 永远开启 
        while (true) { 
            if (ticket > 0) {//有票 可以卖 
                //出票操作 
                //使用sleep模拟一下出票时间 
                try {
                    Thread.sleep(100); 
                } catch (InterruptedException e) {  
                    e.printStackTrace(); 
                }
                //获取当前线程对象的名字 
                String name = Thread.currentThread().getName(); 
              System.out.println(name + "正在卖第:" + ticket--);
            } 
        } 
    } 
}

测试类：

public class Demo { 
    public static void main(String[] args) { 
        //创建线程任务对象 
        Ticket ticket = new Ticket(); 
        //创建三个窗口对象 
        Thread t1 = new Thread(ticket, "窗口1"); 
        Thread t2 = new Thread(ticket, "窗口2"); 
        Thread t3 = new Thread(ticket, "窗口3"); 
        //同时卖票 
        t1.start(); 
        t2.start(); 
        t3.start(); 
    } 
}

结果中有一部分这样现象：

在这里插入图片描述

发现程序出现了两个问题：

相同的票数,比如5这张票被卖了两回。
不存在的票，比如0票与-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized)来解决。

根据案例简述：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，
窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码 去执行。
也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，
等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，
保证了数据的同步性，解决了线程不安全的现象。

有三种方式完成同步操作：

同步代码块。
同步方法。
锁机制。

同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式：

synchronized(同步锁){ 
    需要同步操作的代码
}

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁。

锁对象可以是任意类型。
多个线程对象要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 (BLOCKED)。

使用同步代码块解决代码：

public class Ticket implements Runnable{ 
    private int ticket = 100; 
    
    Object lock = new Object(); 
    
    /** 执行卖票操作 */ 
    @Override public void run() { //每个窗口卖票的操作 
        //窗口 永远开启
        while(true){ 
            synchronized (lock) { 
                if(ticket>0){//有票 可以卖 
                    //出票操作 //使用sleep模拟一下出票时间 
                    try {
                        Thread.sleep(50); 
                    } catch (InterruptedException e) { 
                        // TODO Auto‐generated catch block 
                        e.printStackTrace(); 
                    }
                    //获取当前线程对象的名字 
                    String name = Thread.currentThread().getName(); 
                    System.out.println(name+"正在卖:"+ticket--); 
                } 
            }
        } 
    } 
}

同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证一个线程执行该方法的时候,其他线程只能在方法外等着。

格式：

public synchronized void method(){ 
    可能会产生线程安全问题的代码 
}

同步锁是谁?

对于非static方法,同步锁就是this。

对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

使用同步方法代码如下：

public class Ticket implements Runnable{ 
    private int ticket = 100; 
   
    /** 执行卖票操作 */  
    @Override public void run() { //每个窗口卖票的操作 
        //窗口 永远开启 
        while(true){ 
            sellTicket(); 
        } 
    }
    
    /*
    * 锁对象 是 谁调用这个方法 就是谁 
    * 隐含 锁对象 就是 this 
    *
    */ 
    public synchronized void sellTicket(){ 
        if(ticket>0){//有票 可以卖 
            //出票操作 
            //使用sleep模拟一下出票时间 
            try {
                Thread.sleep(100); 
            } catch (InterruptedException e) { 
                // TODO Auto‐generated catch block 
                e.printStackTrace();
            }
            //获取当前线程对象的名字 
            String name = Thread.currentThread().getName(); System.out.println(name+"正在卖:"+ticket--); 
        } 
    } 
}

Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

使用如下：

public class Ticket implements Runnable{ 
    private int ticket = 100; 
    Lock lock = new ReentrantLock(); 
    
    /** 执行卖票操作 */ 
    @Override public void run() { //每个窗口卖票的操作 
        //窗口 永远开启 
        while(true){ 
            lock.lock(); 
            if(ticket>0){//有票 可以卖 
                //出票操作 
                //使用sleep模拟一下出票时间
                try {
                    Thread.sleep(50); 
                } catch (InterruptedException e) { 
                    // TODO Auto‐generated catch block 
                    e.printStackTrace(); 
                }
                //获取当前线程对象的名字 
                String name = Thread.currentThread().getName(); System.out.println(name+"正在卖:"+ticket--); 
            }
            lock.unlock(); 
        } 
    } 
}

2.3 线程状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

在这里插入图片描述

Timed Waiting（计时等待）

当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)。

小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行。

Timed Waiting 线程状态图：

在这里插入图片描述

BLOCKED（锁阻塞）

一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

Blocked 线程状态图:

在这里插入图片描述

Waiting（无限等待）

一个正在无限期等待另一个线程执行一个唤醒动作的线程，处于的一种状态。

代码演示：

public class WaitingTest { 
    public static Object obj = new Object(); 
    
    public static void main(String[] args) { 
        // 演示waiting 
        new Thread(new Runnable() { 
            @Override public void run() { 
                while (true){ 
                    synchronized (obj){ 
                        try {
                            System.out.println( Thread.currentThread().getName() +"=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象"); 
                            obj.wait(); //无限等待 
                        } catch (InterruptedException e) { 
                            e.printStackTrace(); 
                        }
                        System.out.println( Thread.currentThread().getName() + "=== 从waiting状 态醒来，获取到锁对象，继续执行了"); 
                    } 
                } 
            } 
        },"等待线程").start(); 
        
        new Thread(new Runnable() {
            @Override public void run() { 
                // while (true){ 
                //每隔3秒 唤醒一次 
                try {
                    System.out.println( Thread.currentThread().getName() +"‐‐‐‐‐ 等待3秒钟"); 
                    Thread.sleep(3000); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                }synchronized (obj){ 
                    System.out.println( Thread.currentThread().getName() +"‐‐‐‐‐ 获取到锁对 象,调用notify方法，释放锁对象"); 
                    obj.notify(); 
                } 
            }
            // } 
        },"唤醒线程").start(); 
    } 
}

通过上述案例我们会发现，一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的 Object.notify()方法或 Object.notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入 Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

Waiting 线程状态图：

在这里插入图片描述

线程间通信

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

如何保证线程间通信有效利用资源：等待唤醒机制。

等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争，例如争夺锁，但是线程间也会有协作机制。

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

wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法：

Object.wait()：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。
Object.notify()：选取所通知对象的 wait set 中的一个线程释放。
Object.notifyAll()：释放所通知对象的 wait set 上的全部线程。

等待唤醒机制其实就是经典的“生产者与消费者”的问题。

代码演示：

巧克力类：

public class Chocolate {
    private boolean flag = false;//巧克力资源状态
    
    //setter、getter略
}

顾客类：

public class Customer implements Runnable {
    private Chocolate chocolate;

    public Customer(Chocolate chocolate) {
        this.chocolate = chocolate;
    }

    @Override
    public void run() {
        //消费巧克力
        while (true) {
            synchronized (chocolate) {
                if (chocolate.isFlag() == false) {//没有巧克力
                    try {
                        chocolate.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("吃巧克力咯~~");
                chocolate.setFlag(false);
                chocolate.notify();
            }

        }
    }
}

巧克力商店类：

public class ChocolateStore implements Runnable {
    private Chocolate chocolate;

    public ChocolateStore(Chocolate chocolate) {
        this.chocolate = chocolate;
    }

    @Override
    public void run() {
        //生产巧克力
        while (true) {
            synchronized (chocolate) {
                if (chocolate.isFlag() == true) {
                    try {
                        chocolate.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //没有巧克力，生产 巧克力
                //模拟生产巧克力所需要的时间
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("开始生产巧克力...");

                chocolate.setFlag(true);
                System.out.println("巧克力生产好啦！");
                chocolate.notify();
            }
        }
    }
}

测试类:

public class Test {
    public static void main(String[] args) {
         //等待唤醒案例
        Chocolate chocolate = new Chocolate();
        new Thread(new Customer(chocolate)).start();
        new Thread(new ChocolateStore(chocolate)).start();
    }
}

运行结果：

开始生产巧克力...
巧克力生产好啦！
吃巧克力咯~~
开始生产巧克力...
巧克力生产好啦！
吃巧克力咯~~

状态之间的转换

各个状态之间的转换图：

在这里插入图片描述

注意：

Waiting（无限等待）状态中wait方法是空参的，而timed waiting（计时等待）中wait方法是带参的。这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；如果在倒计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

03 线程池、Lambda表达式

3.1 线程池

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

我们通过一张图来了解线程池的工作原理：

在这里插入图片描述

合理利用线程池能够带来三个好处：

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

线程池的使用

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

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

Executors类中有个创建线程池的方法如下：

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行

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

创建线程池对象。
创建Runnable接口子类对象。(task)
提交Runnable接口子类对象。(take task)
关闭线程池(不建议执行)。

Runnable实现类代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了： " + Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
    }
}

线程池测试类：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        // 创建Runnable实例对象
        MyRunnable r = new MyRunnable();

        //自己创建线程对象的方式
        // Thread t = new Thread(r);
        // t.start(); ---> 调用MyRunnable中的run()

        // 从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        // 再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
        // 将使用完的线程又归还到了线程池中
        // 关闭线程池
        //service.shutdown();
    }
}

3.2 Lambda表达式

函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。

面向对象的思想:

做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情。

函数式编程思想:

只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程。

冗余的Runnable代码

当需要启动一个线程去完成任务时，通常会通过java.lang.Runnable接口来定义任务内容，并使用java.lang.Thread类来启动该线程。代码如下：

public class Demo01Runnable {
	public static void main(String[] args) {
    	// 匿名内部类
		Runnable task = new Runnable() {
			@Override
			public void run() { // 覆盖重写抽象方法
				System.out.println("多线程任务执行！");
			}
		};
		new Thread(task).start(); // 启动线程
	}
}

代码分析

对于Runnable的匿名内部类用法，可以分析出几点内容：

Thread类需要Runnable接口作为参数，其中的抽象run方法是用来指定线程任务内容的核心；
为了指定run的方法体，不得不需要Runnable接口的实现类；
为了省去定义一个RunnableImpl实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象run方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
而实际上，似乎只有方法体才是关键所在。

编程思想转换

做什么，而不是怎么做

我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将run方法体内的代码传递给Thread类知晓。

传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

体验Lambda的更优写法

借助Java 8的全新语法，上述Runnable接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：

public class Demo02LambdaRunnable {
	public static void main(String[] args) {
		new Thread(() -> System.out.println("多线程任务执行！")).start(); // 启动线程
	}
}

匿名内部类的好处与弊端

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

语义分析

仔细分析该代码中的语义，Runnable接口只有一个run方法的定义：

public abstract void run();

即制定了一种做事情的方案（其实就是一个函数）：

同样的语义体现在Lambda语法中，要更加简单：

() -> System.out.println("多线程任务执行！")

Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

一些参数
一个箭头
一段代码

Lambda表达式的标准格式为：

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

格式说明：

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

无参数无返回值

给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。如下：

public interface Cook {
    void makeFood();
}

在下面的代码中，请使用Lambda的标准格式调用invokeCook方法：

public class Demo05InvokeCook {
    public static void main(String[] args) {
        // TODO 请在此使用Lambda【标准格式】调用invokeCook方法
    }

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

解答

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

有参数有返回值

需求:
    使用数组存储多个Person对象
    对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

下面举例演示java.util.Comparator<T>接口的使用场景代码，其中的抽象方法定义为：

public abstract int compare(T o1, T o2);

假设有一个Person类：

public class Person { 
    private String name;
    private int age;
    
    // 省略构造器、toString方法与Getter Setter 
}

传统写法

如果使用传统的代码对Person[]数组进行排序，写法如下：

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

public class Demo06Comparator {
    public static void main(String[] args) {
      	// 本来年龄乱序的对象数组
        Person[] array = {
        	new Person("古力娜扎", 19),
        	new Person("迪丽热巴", 18),
       		new Person("马尔扎哈", 20) };

      	// 匿名内部类
        Comparator<Person> comp = new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        };
        Arrays.sort(array, comp); // 第二个参数为排序规则，即Comparator接口实例

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

Lambda写法

import java.util.Arrays;

public class Demo07ComparatorLambda {
    public static void main(String[] args) {
        Person[] array = {
          	new Person("古力娜扎", 19),
          	new Person("迪丽热巴", 18),
          	new Person("马尔扎哈", 20) };

        Arrays.sort(array, (Person a, Person b) -> {
          	return a.getAge() - b.getAge();
        });

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

练习

给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值：

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

在下面的代码中，请使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算：

public class Demo08InvokeCalc {
    public static void main(String[] args) {
        // TODO 请在此使用Lambda【标准格式】调用invokeCalc方法来计算120+130的结果ß
       
    }

    private static void invokeCalc(int a, int b, Calculator calculator) {
        int result = calculator.calc(a, b);
        System.out.println("结果是：" + result);
    }
}

解答

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

Lambda的省略写法

上例还可以使用Lambda的省略写法：

public static void main(String[] args) {
  	invokeCalc(120, 130, (a, b) -> a + b);
}

省略规则:

在Lambda标准格式的基础上，使用省略写法的规则为：

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

Lambda的使用前提

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

使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。