Java基础加强重温_07：异常、异常处理、finally代码块、自定义异常、多线程、创建线程、Thread类

摘要

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 。

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异常处理的五个关键字：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三者的区别：
https://blog.csdn.net/tiangongkaiwu152368/article/details/68958367
finalize()：
https://blog.csdn.net/a4171175/article/details/90749839

异常注意事项

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、进程和线程

进程

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

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

线程

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

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

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的使用权才能执行指令。

五、并发与并行

并行

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

并发

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

并发和并行图解

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行。
在单 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);
		}
	}
}

多线程执行流程图

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

多线程执行内存图

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

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

八、创建线程的方式

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