JavaSE从头再来（五）——异常与多线程

从头再来第五弹，涉及异常和多线程相关

文章目录

JavaSE从头再来（五）——异常与多线程

一、异常

1.1 异常概念

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

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

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

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

1.2 异常体系

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

Throwable体系：

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

Throwable中的常用方法：

public void printStackTrace():打印异常的详细信息。

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

提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。

出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。

1.3 异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

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

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

1.4 异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常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");
    }
}

上述程序执行过程图解：

二、异常的处理

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

2.1 抛出异常throw

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

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

创建一个异常对象。封装一些提示信息(信息可以自己编写)。
需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

 throw new 异常类名(参数);

例如：

 throw new NullPointerException("要访问的arr数组不存在");
 
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

学习完抛出异常的格式后，我们通过下面程序演示下throw的使用。

 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声明处理。

2.2 Objects非空判断

还记得我们学习过一个类Objects吗，曾经提到过它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作。

public static <T> T requireNonNull(T obj):查看指定引用对象不是null。

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

 public static <T> T requireNonNull(T obj) {
    if (obj == null)
      	throw new NullPointerException();
    return obj;
}
 
//直接调用Objects
public static void fun(Object obj){
    Objects.requireNonNull(obj);
    //如果为空则抛出异常，不为空则返回obj
}

2.3 声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。

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

声明异常格式：

 修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

声明异常的代码演示：

 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这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            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")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
        if (!path.equals("b.txt")) {
            throw new IOException();
        }
    }
}

2.4 捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
在方法中使用try-catch的语句块来处理异常。

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

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

捕获异常语法如下：

 try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

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

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

注意: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")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
    }
}

如何获取异常信息：

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

public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

2.4 finally 代码块

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

什么时候的代码必须最终执行？

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

finally的语法:

try…catch…finally:自身需要处理异常,最终还得关闭资源。

注意:finally不能单独使用。

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

finally代码参考如下：

 public class TryCatchDemo4 {
    public static void main(String[] args) {
        try {
            read("a.txt");
        } catch (FileNotFoundException e) {
            //抓取到的是编译期异常  抛出去的是运行期 
            throw new RuntimeException(e);
        } finally {
            System.out.println("不管程序怎样，这里都将会被执行。");
        }
        System.out.println("over");
    }
    /*
     *
     * 我们 当前的这个方法中 有异常  有编译期异常
     */
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
    }
}

当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。

2.5 异常注意事项

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

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

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

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

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

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

2.6 异常处理的简单理解

Java的异常设计可以联想到我们生活中遇到的问题。

当我们遇到一个问题时可以分为两种解决方案

自己解决：这个时候问题在自己手头上就被解决了，我们会继续正常的流程，这个对应try catch处理
交给别人解决：这个时候我们把问题往上抛，只要我们自己解决不了问题，我们就把这个问题留给别人，对应throw、throws，此处的别人就是调用你的对象，这个对象如果不处理异常，则还要继续往上抛，直到有人解决为止。但是你不能无限抛啊，所以如果到了最原始的调用者还没有人try catch解决的话，主方法就直接将异常抛给jvm，jvam的处理方法就是直接结束方法运行。

这就是Java的逐级甩锅制度。

三、自定义异常

3.1 概述

为什么需要自定义异常类:

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

在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类.

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

异常类如何定义:

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

3.2 自定义异常的练习

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

首先定义一个登陆异常类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 LoginException{
        for (String name : names) {
            if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new RegisterException("亲"+name+"已经被注册了！");
            }
        }
        return true;
    }
}

四、多线程

我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？

要解决上述问题,得使用多进程或者多线程来解决.

4.1 并发与并行

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

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

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

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

4.2 线程与进程

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

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度:

分时调度

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

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

抢占式调度详解

大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yGm5I7g7-1590588265734)(http://cdn.1jumao.cn/img/20200525215514.bmp)]

4.3 创建线程类

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

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

代码如下：

测试类：

 public class Demo01 {
	public static void main(String[] args) {
		//创建自定义线程对象
		MyThread mt = new MyThread("新的线程！");
		//开启新线程
		mt.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程！"+i);
		}
	}
}

自定义线程类：

 public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法，完成该线程执行的逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}

注意事项：在运行10次循环时可能观测不到变化，改成10万次就可以了

五、线程

5.1 多线程原理

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

5.2 Thread类

完成操作过程中用到了java.lang.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():返回对当前正在执行的线程对象的引用。

 public class Demo {
    public static void main(String[] args) throws InterruptedException {
        //利用sleep方法实现10秒倒计时
        for (int i = 10; i >= 0 ; i--) {
            System.out.println(i);
            Thread.sleep(1000);
        }
 
    }
}

翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式

4.3 创建线程方式二：Runnable接口

采用 java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

定义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);
		}
	}
}

通过实现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()方法。

4.4 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

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

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

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

六、线程安全

6.1 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个
(本场电影只能卖100张票)

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

模拟票：

 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票，是不存在的

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

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

6.2 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

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

根据案例简述：

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

为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制

这个机制有三种方式

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

6.3 手段1 同步代码块

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

格式:
```
 创建锁对象
Object lock = new Object();
synchronized(lock){
    需要同步的代码块
}
```
同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
1. 锁对象可以是任意类型。
2. 多个线程对象要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着
(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) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } 
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖:" + ticket‐‐);
               }
            }
        }
    }
}

6.4 同步方法

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

格式：

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

同步锁是谁？

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

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

使用同步方法代码如下

 public class Ticket implements Runnable {
	private int ticket = 100;
    //创建锁对象
    Object lock = new Object();
    @Override
    public void run() {
        while (true) {
            //直接执行同步方法
           sellTicket();
        }
    }
    
    //创建同步方法，有线程安全问题的代码放在里面
    public synchronized sellTicket(){
         if (ticket > 0) {
             try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             } 
             String name = Thread.currentThread().getName();
             System.out.println(name + "正在卖:" + ticket‐‐);
         }
    }
}

6.5 Lock锁（推荐）

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

Lock锁也称同步锁，将上锁和解锁方法化了

public void lock() 加同步锁
public void unlock() 解同步锁

 //创建同步锁
Lock lock = new ReentranLock();
//使用同步锁
lock.lock();
 
	可能会有线程安全问题的代码块
    
lock.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) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖:" + ticket‐‐);
            }
            //解锁
            lock.unlock();
        }
    }
}

七、线程状态

7.1 线程状态概述

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

线程状态	导致状态发生的条件
New 新建	线程刚被创建，但是并没有启动，还没调用start方法
Runnable 可运行	线程可以在jvm中运行的状态，可能正在运行自己的代码，也可能没有，这取决于cpu
Blocked 锁阻塞	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting 无限等待	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting 计时等待	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
Teminated 被终止	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

7.2 Timed Waiting（计时等待）

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。

在写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就
强制当前正在执行的线程休眠（暂停执行），以“减慢线程” 。

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

代码

 public class MyThread extends Thread{
    public void run(){
        for(int i = 0;i < 100;i++){
            if(i%10==0){
                System.out.printf("-----"+i);
            }
            System.out.printf(i);
            try {
                Thread.sleep(1000);
                System.out.print(" 线程睡眠1秒！\n");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
        new Mythread().start();
    }
}

进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协
作关系。
为了让其他线程有机会执行，可以将Thread.sleep()的调用**放线程****run()**之内。这样才能保证该线程执行过程
中会睡眠
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态

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

Timed Waiting 线程状态图：

7.3 BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态

Blocked 线程状态图

7.4 Waiting（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

 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){
                        System.out.println(Thread.currentThread().getName()+"===获取到锁对象，调用wait方法，进入waiting状态，释放锁对象");
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"===从waiting状态唤醒来，获取到锁对象，继续执行了");
                    }
                }
            }
        },"等待线程").start();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "===等待3秒钟");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(obj){
                    System.out.println(Thread.currentThread().getName() + "===获取到锁对象，调用notify方法，释放锁对象");
                    obj.notify();
                }
            }
        },"唤醒线程").start();
    }
}

输出结果：

等待线程—获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
唤醒线程—等待3秒钟
唤醒线程—获取到锁对象，调用notify方法，释放锁对象
等待线程—从waiting状态唤醒来，获取到锁对象，继续执行了
等待线程—获取到锁对象，调用wait方法，进入waiting状态，释放锁对象

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

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

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

7.5 总结

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

posted @ 2022-10-22 12:16 konley 阅读(16) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· JavaSE从头再来（四）：单元测试、反射

· JavaSE从头再来（七）——增强IO流

· 【Java】异常、线程

· JavaSE day07-异常,多线程

· 学习笔记 - 异常和多线程

公告

昵称： konley
园龄： 4年7个月
粉丝： 0
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

	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");
	}
	}

	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;
	}
	}

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

	//直接调用Objects
	public static void fun(Object obj){
	Objects.requireNonNull(obj);
	//如果为空则抛出异常，不为空则返回obj
	}

	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这个文件
	// 我假设如果不是 a.txt 认为该文件不存在是一个错误也就是异常 throw
	throw new FileNotFoundException("文件不存在");
	}
	}
	}

	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")) {//如果不是 a.txt这个文件
	// 我假设如果不是 a.txt 认为该文件不存在是一个错误也就是异常 throw
	throw new FileNotFoundException("文件不存在");
	}
	if (!path.equals("b.txt")) {
	throw new IOException();
	}
	}
	}

	try{
	编写可能会出现异常的代码
	}catch(异常类型 e){
	处理异常的代码
	//记录日志/打印异常信息/继续抛出异常
	}

	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")) {//如果不是 a.txt这个文件
	// 我假设如果不是 a.txt 认为该文件不存在是一个错误也就是异常 throw
	throw new FileNotFoundException("文件不存在");
	}
	}
	}

	public class TryCatchDemo4 {
	public static void main(String[] args) {
	try {
	read("a.txt");
	} catch (FileNotFoundException e) {
	//抓取到的是编译期异常抛出去的是运行期
	throw new RuntimeException(e);
	} finally {
	System.out.println("不管程序怎样，这里都将会被执行。");
	}
	System.out.println("over");
	}
	/*
	*
	* 我们当前的这个方法中有异常有编译期异常
	*/
	public static void read(String path) throws FileNotFoundException {
	if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
	// 我假设如果不是 a.txt 认为该文件不存在是一个错误也就是异常 throw
	throw new FileNotFoundException("文件不存在");
	}
	}
	}

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

	// 业务逻辑异常
	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 LoginException{
	for (String name : names) {
	if(name.equals(uname)){//如果名字在这里面就抛出登陆异常
	throw new RegisterException("亲"+name+"已经被注册了！");
	}
	}
	return true;
	}
	}

	public class Demo01 {
	public static void main(String[] args) {
	//创建自定义线程对象
	MyThread mt = new MyThread("新的线程！");
	//开启新线程
	mt.start();
	//在主方法中执行for循环
	for (int i = 0; i < 10; i++) {
	System.out.println("main线程！"+i);
	}
	}
	}

	public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
	//调用父类的String参数的构造方法，指定线程的名称
	super(name);
	}
	/**
	* 重写run方法，完成该线程执行的逻辑
	*/
	@Override
	public void run() {
	for (int i = 0; i < 10; i++) {
	System.out.println(getName()+"：正在执行！"+i);
	}
	}
	}

	public class Demo {
	public static void main(String[] args) throws InterruptedException {
	//利用sleep方法实现10秒倒计时
	for (int i = 10; i >= 0 ; i--) {
	System.out.println(i);
	Thread.sleep(1000);
	}

	}
	}

	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 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();
	}
	}

Konley

逆风如解意，容易莫摧残。

JavaSE从头再来（五）——异常与多线程

JavaSE从头再来（五）——异常与多线程

文章目录

一、异常

1.1 异常概念

1.2 异常体系

1.3 异常分类

1.4 异常的产生过程解析

二、异常的处理

2.1 抛出异常throw

2.2 Objects非空判断

2.3 声明异常throws

2.4 捕获异常try…catch

2.4 finally 代码块

2.5 异常注意事项

2.6 异常处理的简单理解

三、自定义异常

3.1 概述

3.2 自定义异常的练习

四、多线程

4.1 并发与并行

4.2 线程与进程

4.3 创建线程类

五、线程

5.1 多线程原理

5.2 Thread类

4.3 创建线程方式二：Runnable接口

4.4 Thread和Runnable的区别

六、线程安全

6.1 线程安全

6.2 线程同步

6.3 手段1 同步代码块

6.4 同步方法

6.5 Lock锁（推荐）

七、线程状态

7.1 线程状态概述

7.2 Timed Waiting（计时等待）

7.3 BLOCKED（锁阻塞）

7.4 Waiting（无限等待）

7.5 总结

公告

搜索

常用链接

随笔档案

阅读排行榜

推荐排行榜

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

	创建锁对象
	Object lock = new Object();
	synchronized(lock){
	需要同步的代码块
	}

	public class Ticket implements Runnable {
	private int ticket = 100;
	//创建锁对象
	Object lock = new Object();
	@Override
	public void run() {
	while (true) {
	//加锁
	synchronized(lock){
	if (ticket > 0) {
	try {
	Thread.sleep(100);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	String name = Thread.currentThread().getName();
	System.out.println(name + "正在卖:" + ticket‐‐);
	}
	}
	}
	}
	}

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

	//创建同步锁
	Lock lock = new ReentranLock();
	//使用同步锁
	lock.lock();

	可能会有线程安全问题的代码块

	lock.unlock();

	public class MyThread extends Thread{
	public void run(){
	for(int i = 0;i < 100;i++){
	if(i%10==0){
	System.out.printf("-----"+i);
	}
	System.out.printf(i);
	try {
	Thread.sleep(1000);
	System.out.print(" 线程睡眠1秒！\n");
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}
	}
	public static void main(String[] args){
	new Mythread().start();
	}
	}

	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){
	System.out.println(Thread.currentThread().getName()+"===获取到锁对象，调用wait方法，进入waiting状态，释放锁对象");
	try {
	obj.wait();
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	System.out.println(Thread.currentThread().getName()+"===从waiting状态唤醒来，获取到锁对象，继续执行了");
	}
	}
	}
	},"等待线程").start();

	new Thread(new Runnable() {
	@Override
	public void run() {
	System.out.println(Thread.currentThread().getName() + "===等待3秒钟");
	try {
	Thread.sleep(3000);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	synchronized(obj){
	System.out.println(Thread.currentThread().getName() + "===获取到锁对象，调用notify方法，释放锁对象");
	obj.notify();
	}
	}
	},"唤醒线程").start();
	}
	}