摘要

Java基础加强重温_07：
异常（错误Error/异常Exception，编译异常/运行异常，查看异常方法printStackTrace，区分异常/错误）、
异常处理（JVM终止，抛出异常throw/应用:Objects非空判断，方法声明异常thorws，捕捉异常try…catch/多catch捕捉异常）、
finally代码块（必须最终执行:资源回收,如关闭连接/关闭资源）、
自定义异常（继承Exception或RuntimeException，调用父类有参构造:输入异常信息）、
多线程（进程/线程，线程调度:分时/抢占，并发/并行）、
创建线程（继承Thread类/实现Runnable接口:线程共享资源/匿名内部类，多线程运行原理）、
Thread类（构造方法:不指定名字/指定名字/指定目标不带名字/指定目标带名字，常用方法:获得线程名字/启动线程/执行线程任务/休眠/获得当前线程对象）

一、异常

异常就是程序在运行或编译过程中出现的问题。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。
Java处理异常的方式是中断处理（中断代码执行）。

1、异常体系

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

java 自定义 enum 包_java

Throwable体系：

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

异常和错误的区别

错误：一般由操作系统反馈给JVM，无法针对错误进行处理，只能修改错误行代码
异常：一般由JVM反馈给Java程序，可以针对异常进行处理（如抛出异常），处理之后程序可以继续运行。如果不处理和错误一样：程序终止运行

如何判断程序出现的问题是错误还是异常？

根据控制台输出的异常类名，如果是Exception结尾的就是异常，否则都是错误。

Throwable中的常用方法：

public void printStackTrace() ：打印异常的详细信息。
	包含了异常的类型,异常的原因,还包括异常出现的位置 
	在开发和调试阶段,经常使用printStackTrace 。
	使用频率最高：追踪栈的异常信息

public String getMessage() 
	获取发生异常的原因。提示给用户的时候 , 就提示错误原因。

public String toString()
	获取异常的类型和异常描述信息。

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

2、异常分类

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

根据在编译时期还是运行时期出现可以分为2类：编译时异常、运行时异常

编译时期异常

除了RuntimeException类以外的所有异常都是编译时异常。
checked异常。在编译时期，编译器会检查，出现异常没有处理，则编译失败。(如日期格式化异常)

运行时期异常

RuntimeException类异常及其子类异常。
runtime异常。在运行时期，JVM检查。在编译时期运行异常不会被编译器器检测(不报错)。(如数学异常)

运行时异常和编译时异常特点

运行时异常(可以处理，也可以不处理)

  • 如果方法体中抛出运行时异常，则可以处理也可以不处理
  • 如果方法声明中声明运行时异常，则调用者可以处理，也可以不处理。

编译时异常(必须要处理)

  • 如果方法体中抛出编译时异常，则要求一定要处理
  • 如果方法声明中声明编译时异常，则要求调用者一定要处理

为什么编译器对运行时异常管理如此松散？

  • 因为运行时异常一般是可以通过程序猿良好的编程习惯避免
区分编译时异常还是运行时异常

查看文档，看继承体系，如果有RuntimeException则是运行时异常，否则都是编译时异常。

3、异常产生的过程

  1. JVM执行到有问题的代码时会根据问题的原因找到对应异常类
  2. 根据异常类创建异常对象，封装，并将异常对象抛给方法调用者
  3. 如果方法调用者没有对异常进行处理，则继续向上抛，直到抛给了JVM
  4. JVM接收到异常对象之后会将异常信息输出并终止程序运行。

图解示例

java 自定义 enum 包_编程语言_02

二、异常的处理

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

1、JVM处理异常

方法调用者不处理异常，一直往上抛，抛到JVM时。

JVM处理异常的方式：

  1. 将异常信息输出到控制台(异常类名，异常原因，异常位置)
  2. 退出JVM终止程序运行。

2、抛出异常throw

定义方法时，方法需要接受参数。当调用方法使用接受的参数时，首先需要先对参数据进行合法的判断，数据若不不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

java中提供了一个throw关键字，用来抛出一个指定的异常对象。
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

区别：
throw用在方法内
throw用在方法声明上

使用格式：

throw new 异常类名(参数);

使用步骤

  1. 创建一个异常对象。封装一些提示信息(信息可以⾃己编写)。
  2. 需要将这个异常对象告知给调用者。通过关键字throw完成。
    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声明处理

3、Objects类的非空判断（throw在源码的应用）

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

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

Objects抛出异常源码

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

4、声明异常throws

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

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

声明异常格式：

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

代码示例1（抛出单个异常）

main方法调用read方法，read方法声明抛出异常，main方法再抛出异常

public class ThrowsDemo {
	//方法声明throws抛出异常
	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("⽂文件不不存在");
		}
	}

}

代码示例1（抛出多个异常）

若该方法可能有多种异常情况产生，那么在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();
		}
	}
}

一般直接抛出一个包括多种异常子类的大的父类异常（Exception是所有子类）

小结

thow与thows的区别

  1. throw关键字的作用和格式
    作用：将异常对象抛给方法调用者并结束当前方法的运行。
    位置：使用在方法体中
    格式：throw 异常对象;
  2. throws关键字的作用和格式
    作用：将异常对象标识出来告诉给方法调用者方法内部可能会出现的异常：提醒调用者注意处理异常。
    位置：使用在方法声明上
    格式：修饰符 返回值类型 方法名(参数列表) throws 异常类名1,… { }

4、捕获异常try…catch

如果异常出现的话，不处理异常会立刻终止程序，所以我们得处理异常。2种处理方式：

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

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

捕获异常语法格式
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("⽂文件不不存在");
		}
	}
}

多个异常的捕获处理

  1. 多个异常分别处理。
  2. 多个异常一次捕获，多次处理。
  3. 多个异常一次捕获一次处理。

我们一般使用一次捕获多次处理方式（多catch捕捉）。

try{
	编写可能会出现异常的代码

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

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

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

查看异常的方法（获取异常信息）

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

public String getMessage()：获取异常的描述信息，原因。(提示给用户的时候，提示错误原因。）

public String toString()：获取异常的类型和异常描述信息。

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

使用格式：异常对象.方法

代码示例
public class Demo06 {
    public static void main(String[] args) {
       test01();
    }

    public static void test01() {
        test02();
    }

    public static void test02() {
        try{
            System.out.println(100/0);
        } catch(Exception e){
            // 获得异常原因字符串
            // System.out.println(e.getMessage());
            // 获得异常类型和异常原因字符串
            // System.out.println(e.toString());
            // 追踪栈的异常信息
            e.printStackTrace();
        }
    }
}

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

在开发中可以在catch将编译期异常转换成运行期异常处理。

5、finally代码块

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

finally代码的的作用：一般用来释放资源，比如关闭IO流，关闭连接

finally的语法:

try...catch....finally：在try...catch捕捉异常处理，最终还得关闭try代码块中打开的资源。

注意：finally不不能单独使⽤用。

必须最终执行的代码

当我们在try语句块中打开了一些物理资源(磁盘文件/⽹络连接/数据库连接等)，都得在使用完之后，关闭打开的资源。一直打开会导致内存消耗。

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

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("文件不存在");
		}
	}
}

finally代码的的特点

只要代码执行流程进入了try代码块，不管try代码块的代码是否有异常，finally代码块的代码都会执行。
只有在try或者catch中调用退出JVM的相关方法，此时finally才不会执行。

面试题：final、finally与finalize三者的区别

final为常量关键字，而finally为异常关键字，finalize为object类自带的方法名。

final、finally与finalize三者的区别：

finalize()：

异常注意事项

1、运行时异常被抛出可以不处理。即不捕获也不声明抛出。
2、继承关系中，如果父类方法抛出了多个异常，子类重写父类方法时，只能抛出相同的异常或者是它的子集。
3、父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获
处理，不能声明抛出。
4、当多异常处理时，捕获处理，前面catch的异常类不能是后面catch的异常类的父类（理解：catch括号里面的异常类范围按顺序从小到大，上子下父）
5、在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。

三、自定义异常

为什么需要自定义异常类:
Java中不同的异常类分别代表某一种具体的异常情况，但在开发中总是有些异常情况是SUN公司没有定义好的，此时我们可以根据自己业务的异常情况来定义异常类。例如年年龄负数问题，考试成绩负数问题。

通俗讲，就是JDK提供的异常虽然很多，但是不一定符合我们的需求，此时我们可以根据自己的业务来定义异常类。

自定义异常类格式

  1. 自定义编译时异常类: 自定义类继承ava.lang.Exception 。
    自定义类中，有参构造中super调用父类有参构造。传递参数（异常信息）
  2. 自定义运行时异常类：自定义类继承 java.lang.RuntimeException 。
    自定义类中，有参数构造super调用父类有参构造。传递参数（异常信息）

自定义异常案例1

/**
 1. 创建一个类继承Exception或RuntimeException
 */
public class No18AgeException extends Exception{

    // 2. 提供两个构造方法
    // 无参数构造
    public  No18AgeException(){}

    // 有参数构造super调用父类有参构造。传递参数
    public No18AgeException(String message){
        super(message);
    }

}

自定义异常案例2

需求

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

代码实现

定义一个登陆异常类LoginException，

public class LoginException extends Exception {

	public LoginException() {
	}

	/**
	* @param message 表示异常提示
	*/
	public LoginException(String message) {
		//调用父类Exception有参构造
		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(LoginException e){
			//处理理异常
			e.printStackTrace();
		}
	}

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

四、多线程

程序在没有跳转语句句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？要解决这个问题，我们得使用多进程或者多线程来解决。

1、进程和线程

进程

进程是指一个内存中运行的应用程序。
每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；
进程也是程序的一次执行过程，是系统运行程序的基本单位。
系统运行一个程序即是一个进程从创建、运行到消亡的过程。

理解：线程即一个正在运行中的程序

java 自定义 enum 包_父类_03

线程

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。
一个进程中也可以有多个线程，这个应用程序也可以称之为多线程程序。

理解：线程是进程中的一个独立执行单元，进程中的一个独立执行路径。

java 自定义 enum 包_java 自定义 enum 包_04

2、进程与线程的作用

进程作用：用来封装线程，为线程执行任务提供资源(内存资源)
线程作用：用来执行代码

3、进程与线程的区别

进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，一个进程里面至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多

理解：
进程和线程比喻
进程：工厂
线程：工人

1、一个进程中的多个线程是并发运行的，但从微观角度看还是有先后顺序的，哪个线程先执行，完全取决于 CPU 的调度，程序员是干涉不了。这也造成了多线程的随机性。
2、Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。
3、由于创建一个线程的开销比创建一个进程的开销小得多，所以我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。

4、线程调度

计算机通常只有一个CPU时，在任意时刻只能执行一条计算机指令，每一个进程只有获得CPU的使用权才能执⾏行指令。所谓多进程并发运行，从宏观上看，其实是各个进程轮流获得CPU的使用权，分别执行各自的任务。在可运行池中，会有多个线程处于就绪状态等待CPU使用权，JVM就负责了线程的调度。JVM采用的是抢占式调度，没有采用分时调度，因此可能造成多线程执行结果的的随机性。

5、线程运行模式

1、分时式模式：
所有线程平均分配CPU使用权

2、抢占式模式：
所有线程一起抢夺CPU使用权，哪个线程抢夺到就执行哪个线程的任务。
CPU随机选择一个线程执行，选择到哪个线程就执行哪个线程的任务。
Java程序中的线程运行模式属于抢占式模式

当计算机的CPU是单核时，在任意时刻只能执行一条机器指令，每个线程只有获得CPU的使用权才能执行指令。

五、并发与并行

并行

指两个或多个事件在同一时刻发生（同时发生）。理解：即在同一个时间点同时执行多个任务

并发

指两个或多个事件在同一个时间段内发生。理解：即在某一个时间范围同时执行多个任务

并发和并行图解

java 自定义 enum 包_java_05


在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行。

在单 CPU系统中，每一时刻只能有一道程序执行，微观上这些程序是分时交替运行的，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常非常短。

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

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

六、Thread类（线程）

java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例.

每个线程的作用是完成一定的任务，实际上就是执行一段程序流，即一段按顺序执行的代码。Java使用线程执行体来表示这段程序流。

理解：线程类，只要是该类的对象就是一个线程(相当于一个工人)

构造方法：

public Thread() :分配一个新的线程对象。不指定线程名字会用系统默认的名字：thread-1，thread-2，...
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 Demo16 {
    public static void main(String[] args) throws InterruptedException {
        // 创建线程对象
        MyThread t = new MyThread();

        // 设置线程名称
        t.setName("下载文件A线程");

        // 获得线程名称：默认名字：Thread-序号
        System.out.println(t.getName());

        // 开启线程
        t.start();

        // 让主线程休眠1秒
        Thread.sleep(1000);

        for (int i = 0; i < 10; i++) {
            System.out.println("main...." + i);
        }

        // 获得当前线程对象
        Thread mt = Thread.currentThread();
        // 获得主线程名称
        System.out.println(mt.getName());


    }
}

1、多线程（主线程和子线程）

主线程：
程序启动过程中自动创建并执行main方法的线程，其他的为子线程
子线程：
除了主线程（main方法的线程）以外的所有线程都是子线程

Java程序启动时会创建两个线程：一个是主线程，一个垃圾回收器线程（子线程）。

线程执行路径
主线程：从main开始直到main方法结束
子线程：从run方法开始直到run方法结束

区分主线程和子线程
根据线程名称判断，如果是main则主线程，否则都是子线程。

2、创建多个多线程步骤

Java中通过继承Thread类来创建线程并启动多线程，步骤如下：

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

2、多线程案例（继承Thread类创建线程）

需求：
执行自定义线程类线程，和main方法线程(主线程)

步骤：
创建线程的步骤

  1. 创建一个类继承Thread类
  2. 重写run方法：用来编写线程任务代码
  3. 创建子类对象
  4. 调用start方法开启线程：自动执行run方法

代码示例：

自定义线程类：
1、创建类继承Thread，添加有参构造，里面调用Thread类thread(String:name)构造方法。

  • 快捷生成：idea的自定义线程类中，右键->Genetate->Constructor->找到thread(String:name)
    2、重写run方法。重写的run方法体中编写线程需要执行的逻辑代码
public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}

	/**
	* 重写run方法，完成该线程执行的逻辑
	*/
	@Override
	public void run() {
		for (int i = 0; i < 200; i++) {
			System.out.println(getName()+"：正在执⾏行行！"+i);
		}
	}
}

测试类：

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

七、多线程运行原理

CPU来回的在多个线程之间切换调度，调度到哪个线程就执行哪个线程的代码。

代码示例

自定义线程类：

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 Demo {
	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);
		}
	}
}

多线程执行流程图

java 自定义 enum 包_java_06


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

多线程执行内存图

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

java 自定义 enum 包_抛出异常_07


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

八、创建线程的方式

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

1、继承Thread类

继承Thread类的子类对象，都是一个线程

2、实现Runnable接口

通过实现java.lang.Runnable接口创建线程对象的方式也是非常常见的一种，我们只需要重写Runnable接口run⽅法即可。

Runnable接口的实现类对象，不是线程，是Runnable任务（即Thread类的target）
还要通过new Thread()时，Thread类构造方法提交Runnable任务，创建出来的Thread类对象才是线程。

Thread类构造方法:
public Thread(Runnable target) :分配一个带指定目标的新的线程对象。
public Thread(Runnable target,String name) :分配一个带指定目标的新的线程对象，并指定线程名字
实现Runnable接口创建线程比继承Thread类所具有的优势：
  1. 可以更好的在多个线程之间共享数据(卖票案例)
    理解：实现Runnable接口的类的对象不是线程对象，仅仅作为Thread对象的target，通过这个target可以创建多个线程对象（Thread对象），这时多个线程共享实现类里面的数据（如成员变量）
  2. 解决了Java类单继承的局限性
  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
  4. 为线程池提供前提条件
    理解：线程池里线程，一定是通过实现Runnable或Callable接口的方法创建的，通过继承Thread类创建的线程实例，无法放到线程池中。

创建线程的四种方式：Thread，Runnable，Callable，线程池：
https://baijiahao.baidu.com/s?id=1637288381400274766&wfr=spider&for=pc

继承Thread类和实现Runnable接口的区别

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

九、创建线程的案例

1、案例1（通过实现Runnable接口创建线程）

步骤如下：

实现Runnable接口创建线程的步骤

  1. 创建一个类实现Runnable接口
  2. 重写接口中的run方法：用来封装线程任务的代码
  3. 创建接口实现类对象
    实现类对象只是线程对象（Thread对象）的targe
  4. 根据接口实现类对象创建Thread对象
    该Thread对象才是真正的线程对象。
  5. 调用start方法开启线程

代码实现

自定义类实现Runnable接口，重写run()方法

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();
		//创建线程对象，提交Runnable任务并命名线程
		Thread t = new Thread(mr, "小强");
		t.start();
		
		for (int i = 0; i < 20; i++) {
			System.out.println("旺财 " + i);
		}
	}
}

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

小结：

1、通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有多线程的任务代码都在run方法里面。Thread类实际上也是实现了了Runnable接口的类。
2、在启动多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出线程对象，Thread对象调用start()方法来运行多线程代码。
3、实际上所有的多线程代码都是通过运行Thread类的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

2、案例2（匿名内部类方式创建线程）

使用匿名内部类创建线程的方式，可以方便地实现每个线程执行不同的线程任务操作

匿名内部类语法回顾

new 类名或接口名(){}
    直接创建已知类的子类对象
    直接创建已知接口的实现类对象。

匿名内部类创建线程的2种方式

//匿名内部类继承Thread类
new Thread(){
	public void run(){}
}.start();

//匿名内部类实现接口，再传入Thread构造方法
new Thread(
	new Runnble(){ public void run(){
	
	}}
).start();

代码示例

public class Demo18 {
    public static void main(String[] args) {
        // Thread类：直接创建Thread类的子类对象
        /**
            1. 创建一个类：XxxThread
                class XxxThread extends Thread{
                    @Override
                    public void run() {
                        System.out.println("run..." + getName());
                    }
                }
            2. 创建子类对象
                Thread t =  new XxxThread();

            3. 开启线程
                t.start();
         */
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("run..." + getName());
            }
        };
        // 开启线程
        t.start();

        // 简化形式
        new Thread(){
            @Override
            public void run() {
                System.out.println("run..." + getName());
            }
        }.start();

        // Runnable接口：直接创建Runnable接口实现类对象
        /*
            1. 创建类实现Runnable接口
                    class XxxRunnable implements Runnable{
                        @Override
                        public void run() {
                            System.out.println("run..." + Thread.currentThread().getName());
                        }
                    }
             2. 创建接口实现类对象
                    Runnable target = new XxxRunnable();

         */
        Runnable target = new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable...run..." + Thread.currentThread().getName());
            }
        };
        new Thread(target).start();

        // 简化格式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable...run..." + Thread.currentThread().getName());
            }
        }).start();
    }
}