主要内容

异常、线程

第一章异常

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) {// 2. 正常逻辑代码 ...int element = arr[index];return element;}
}

测试类

public class ArrayToolsTest1 {public static void main(String[] args) {// 定义一个数组int[] arr = {10, 20, 30};// 调用工具类的方法int element = ArrayTools.getElement(null, 2);// 查看结果System.out.println("element = " + element);System.out.println("程序执行完毕 ...");}
}

上述程序执行过程图解：

第二章异常的处理

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 ArrayTools {// 行为 : 根据传入的数组与下标, 返回指定的元素public static int getElement(int[] arr, int index) {// 0.1 判断, arr 是否为 nullif (arr == null) {// 0.2 抛出一个 `异常`// 程序一旦执行到 throw 代码, 后续代码就不执行了, 此时, 程序就会直接返回到调用处.throw new NullPointerException("数组引用不能为空, 请修正代码.");}// 1.1 判断, index 是否越界if (index < 0 || index >= arr.length) {// 1.2 抛出一个 `异常`, 提前终止程序的执行// 格式 : throw new 异常类型(自定义信息);throw new ArrayIndexOutOfBoundsException("数组下标越界异常, 请修正代码.");}// 2. 正常逻辑代码 ...int element = arr[index];return element;}
}public class ArrayToolsTest1 {public static void main(String[] args) {/*String str = "abcdefg";// StringIndexOutOfBoundsExceptionchar c = str.charAt(str.length());System.out.println("c = " + c);*/// 定义一个数组int[] arr = {10, 20, 30};// 调用工具类的方法int element = ArrayTools.getElement(null, 2);// 查看结果System.out.println("element = " + element);System.out.println("程序执行完毕 ...");}
}输出结果 :
Exception in thread "main" java.lang.NullPointerException: 数组引用不能为空, 请修正代码.

注意：如果产生了问题，我们就会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;
}

import java.util.Objects;// 数组工具类 :
public class ArrayTools {// 行为 : 根据传入的数组与下标, 返回指定的元素public static int getElement(int[] arr, int index) {// 0.1 判断, arr 是否为 null/*if (arr == null) {// 0.2 抛出一个 `异常`// 程序一旦执行到 throw 代码, 后续代码就不执行了, 此时, 程序就会直接返回到调用处.throw new NullPointerException("数组引用不能为空, 请修正代码.");}*/// Objects 工具类提供了一个方法, 可以针对 `对象` 进行空引用判断.// 含义 : 判断 arr 对象是否为空, 如果为空, 底层就会抛出一个 `空引用` 类型.// Objects.requireNonNull(arr);Objects.requireNonNull(arr, "数组引用不能为空, 请修正代码.");// 1.1 判断, index 是否越界if (index < 0 || index >= arr.length) {// 1.2 抛出一个 `异常`, 提前终止程序的执行// 格式 : throw new 异常类型(自定义信息);throw new ArrayIndexOutOfBoundsException("数组下标越界异常, 请修正代码.");}// 2. 正常逻辑代码 ...int element = arr[index];return element;}
}

2.3 声明异常throws

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

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

声明异常格式：

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

声明异常的代码演示：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class ThrowsExceptionTest2 {public static void main(String[] args) throws ParseException {String str = "2018-08-08";parseDate(str);}public static void parseDate(String str) throws ParseException {// 1. 创建一个日期格式化对象SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");// 2. 解析Date date = df.parse(str);// 3. 查看System.out.println("date = " + date);}
}

2.4 捕获异常try…catch

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

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

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

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

捕获异常语法如下：

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

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

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

注意:try和catch都不能单独使用,必须连用。

演示如下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class ExceptionTest1 {public static void main(String[] args) {// 需求 : 将一个字符串解析为一个 `Date` 对象String str1 = "2018年08月08日";String str2 = "2018-08-08";// 调用方法时, 只要调用了 `声明编译时期异常` 的方法, 此时, 程序就会报错.// 含义 : 编译器问调用者, 你调用一个带编译时期的异常方法, 如果发生了该异常, 请问, 您如何处理呢 ???// 回答1 : 编译器兄弟呀, 如果发生了异常, 请将该问题交给我的调用者去处理.   (继续声明 throws)// 回答2 : 编译器兄弟呀, 如果发生了该异常, 请将该异常交给我来处理. 不管我怎么处理, 都与你无关. (异常捕获 try-catch)/*try {// 编写可能会发生异常的代码 ...} catch (异常类型 exception) {// 如果发生了该异常, 这个大括号中就是对该异常进行的处理方案代码 ... (不管写什么. 都是处理方案代码, 哪怕什么都不写)} finally {// 无论是否发生异常, 都会被执行到的代码 ...}*/try {parseStringToDate(str1);} catch (ParseException e) {// 说明 : catch 语句必须发生异常后, 才可以进入.// 打印日志 ... 处理逻辑 ...// System.out.println("发生了解析异常. 传入字符串日期格式错误. 格式: yyyy-MM-dd.");// 含义 : 输出异常发生的堆栈信息e.printStackTrace();            // Throwable 类定义的方法.// getMassage & toString()String message = e.getMessage();String str = e.toString();System.out.println("message = " + message);System.out.println("str = " + str);}// 后续代码 ...int num1 = 10;int num2 = 20;int sum = num1 + num2;System.out.println("sum = " + sum);System.out.println("程序正常执行完毕 ...");}// 异常声明 : 位置 (方法参数列表之后)    格式 : throws 异常类型public static void parseStringToDate(String str) throws ParseException {// 1. 创建一个 `简单日期格式化` 对象SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");// 2. 将传入的参数实现解析// unhandled exception : java.text.parseException 未处理的异常, 解析异常.// 说明1 : parseException 是编译时期的异常.// 说明2 : NullPointerException / IndexOutOfBoundsException 属于运行时异常.// 说明3 : 如果异常类型为运行时异常, 编译器不检查该类异常, 因此, 程序可以选择不处理.// 说明4 : 如果异常类型为编译时异常, 编译器会检查该类异常, 因此, 程序必须做出处理. 不处理的话, 编译报错, 程序无法运行.// 处理有两种方式 : 1. 继续抛 (继续声明 throws)     2. 异常捕获. (try-catch)// 1. 继续抛 (继续声明 throws)  含义 : 这个异常问题, 我不处理, 交给我的调用者进行处理.// 2. 异常捕获. (try-catch)  含义 : 这个问题交给我来处理, 不用调用者关心.Date date = df.parse(str);// 查看结果System.out.println("date = " + date);}
}输出结果 :
java.text.ParseException: Unparseable date: "2018年08月08日"at java.base/java.text.DateFormat.parse(DateFormat.java:388)at cn.itcast.exception2.ExceptionTest1.parseStringToDate(ExceptionTest1.java:68)at cn.itcast.exception2.ExceptionTest1.main(ExceptionTest1.java:28)
message = Unparseable date: "2018年08月08日"
str = java.text.ParseException: Unparseable date: "2018年08月08日"
sum = 30
程序正常执行完毕 ...

如何获取异常信息：

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

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

2.4 finally 代码块

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

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

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

finally的语法:

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

注意:finally不能单独使用。

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

finally代码参考如下：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;public class ExceptionTest1 {public static void main(String[] args) {String result = readFile("a.txt");System.out.println("result = " + result);}// 需求 : IO (BufferedReader & BufferedWriter)// 说明 : 定义一个方法, 读取指定文件中的数据, 并返回是否读取成功字符串.public static String readFile(String fileName) {// 1. 读取文件// 说明 : 创建 FileReader 时, 会发生一个 `FileNotFoundException` 文件找不到异常.// 选择捕获异常 : try - catchFileReader reader = null;try {reader = new FileReader(fileName);} catch (FileNotFoundException e) {System.out.println("发生了文件找不到异常, 请检查文件路径或文件名称.");// 如果程序进入 catch 语句, 说明程序发生了异常. 文件读取失败了.return "文件读取失败";        // return 之前会先执行 finally 代码块.} finally {// finally 代码块就是为 `关闭资源` 而设计. (硬件文件资源, 数据库资源, 网络资源 ...)// 说明 : finally 块的设计就是为了解决 catch 块中 return 语句的问题.System.out.println("finally 代码块被执行 ...");// 说明 : 如果一个对象的默认值为null, 调用时, 必须要做 null 判断.if (reader != null) {try {reader.close();} catch (IOException exception) {// 忽略 ...}}// finally 块中, 在开发时, 绝对不会出现 return 语句, 因为 finally 块就是用来关闭资源的, 而不是返回结果的.// 如果要返回结果, 请在 catch 语句中返回.// return "哈哈哈哈";}return "文件读取成功";}
}输出结果 :
发生了文件找不到异常, 请检查文件路径或文件名称.
finally 代码块被执行 ...
result = 文件读取失败

当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。
给大家一张好记的图 , 哈哈

2.5 异常注意事项

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集。
父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。

子父类

public class Person {public void introduce() {System.out.println("大家好, 我是 Person 类.");}
}public class Student extends Person {@Overridepublic void introduce() {System.out.println("大家好, 我是 Student 类.");// 子类重写父类的方法, 如果父类被重写的方法没有声明编译时期异常, 子类重写时, 不可以抛出编译时期异常.// 如果有异常, 子类重写方法中, 只能选择 try-catch 语句进行捕获.try {readFile();} catch (FileNotFoundException e) {System.out.println("文件找不到异常.");}}public void readFile() throws FileNotFoundException {FileReader reader = new FileReader("a.txt");}
}

接口与接口实现类

public interface MyRunnable {void run();
}public class MyRunnableImpl implements MyRunnable {@Overridepublic void run() {System.out.println("MyRunnableImpl run ...");// 实现类重写接口中抽象方法时, 如果该抽象方法没有声明编译时期异常, 实现类重写也不能声明该异常.// 如果内部有编译时期异常, 实现类需要在内部使用 try-catch 自行处理.try {readFile();} catch (FileNotFoundException e) {System.out.println("文件不存在, 读取失败!");}}public void readFile() throws FileNotFoundException {FileReader reader = new FileReader("a.txt");}
}

第三章自定义异常

3.1 概述

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

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

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

什么是自定义异常类:

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

自定义一个业务逻辑异常: RegisterException。一个登陆异常类。

异常类如何定义:

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

3.2 自定义异常的练习

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

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

// 自定义了一个 `注册异常` 类
// 说明 : 能抛出的对象都必须继承自 Throwable 类.
// 说明 : 如果是自定异常, 不直接继承 Throwble 类, 可以选择继承 `Exception / RuntimeException` 这两个类.
public class RegisterException extends Exception {// 提供两个构造方法即可.public RegisterException() {super();}public RegisterException(String message) {super(message);}
}

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

public class RegisterTest {// 属性 : 数据库private static String[] names = {"Jack", "Peter", "Tom"};public static void main(String[] args) {try {boolean result = checkUserExists("Jackie");System.out.println("result = " + result);} catch (RegisterException e) {e.printStackTrace();}System.out.println("程序正常执行完毕 ...");}// 行为 : 查看该用户是否已经存在, 如果存在, 不能再注册public static boolean checkUserExists(String username) throws RegisterException {// 判断, 遍历 namesfor (String name : names) {if (name.equals(username)) {// 用户名已经存在, 不能再注册, 需要抛出一个 `RegisterException` 异常.// 说明 : 自己 throw 出来的异常, 只需要声明一下即可.throw new RegisterException("用户是否已经存在, 请重新选择.");}}return true;}
}

3.3 异常流程的思考 :

思考程序运行时输出的序号语句 :

public class ThinkingException {public static void main(String[] args) {System.out.println(1);try {System.out.println(2);int[] arr = {10, 20, 30};System.out.println(arr[3]);     // ArrayIndexOutOfBoundsException: 3System.out.println(3);String str1 = "";System.out.println(str1.toString());System.out.println(4);String str2 = null;System.out.println(str2.toString());        // NullPointerExceptionSystem.out.println(5);int num = 10 / 0;System.out.println("num = " + num);     // ArithmeticException: / by zeroSystem.out.println(6);Object obj = new Object();// 这不是多态 : 子类引用 -> 父类对象 (类型转换错误)String str = (String) obj;      // ClassCastException:System.out.println("str = " + str);System.out.println(7);} catch (ArrayIndexOutOfBoundsException e) {System.out.println(8);} catch (NullPointerException e) {System.out.println(9);} catch (ArithmeticException e) {System.out.println(10);} catch (ClassCastException e) {System.out.println(11);} finally {System.out.println(12);}System.out.println(13);}
}输出结果 :
1
2
8
12
13

说明 : 当多异常处理时，捕获处理，前边的类不能是后边类的父类

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

public class ThinkintExceptionTest2 {public static void main(String[] args) {// 父类 : Exception -> 子类 : IOException -> 子子类 : FileNotFoundExceptiontry {FileReader reader = new FileReader("a.txt");reader.read();} catch (FileNotFoundException e) {     // 子子类System.out.println("FileNotFoundException 被捕获 ...");} catch (IOException e) {               // 子类System.out.println("IOException 被捕获 ...");} catch (Exception e) {                 // 父类System.out.println("Exception 被捕获 ...");}}
}

第四章多线程

多线程 : 理解为程序中的多条执行路径.

迅雷 : 下载电影, 同时下载多部电影, 显示的结果好像是多部电影同时下载.

说明 : 迅雷也是一个程序, 那么一个程序中只存在一个 main 方法. 就一个入口, 如何实现多条执行路径呢 ???

思考 : 同一个Java程序, 可不可以同时执行多个死循环 ???

public class ThreadTest1 {public static void main(String[] args) {// 思考 : 同一个 Java 程序中, 是否可以同时执行多个死循环 ???// 死循环 : (耗时操作)// `常量` 编译器知道数值.        `变量` 编译器是不知道数值.// 为了解决这种现实生活中的问题, Java 出现 `多线程` 的语法.// 网络聊天 (发送 / 接收)     上传下载 (程序的多条执行路径)boolean flag = true;while (flag) {// 电影 1   (1G -> 5分钟)System.out.println("电影 1 下载中 ...");}while (true) {// 电影 2   (1G -> 5分钟)System.out.println("电影 2 下载中 ...");}}
}

4.1 并发与并行

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

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

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

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

4.2 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：进程内部的一个独立执行单元；一个进程可以同时并发的运行多个线程，可以理解为一个进程便相当于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。
进程就理解为 正在执行的程序. 线程就类似于进程中的小进程.
- 进程一般有 操作系统 实现分配, 但是 线程 是由程序编写中实现分配的.

我们可以再电脑底部任务栏，右键----->打开任务管理器,可以查看当前任务的进程和线程：

进程

线程

进程与线程的区别

进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。
- 堆空间是对象, 栈空间是方法. 对象数据是可以共享的, 而方法中局部变量的数据是独立的. 不能共享.

注意：

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

线程调度:

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

4.3 创建线程类

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

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

代码如下：

测试类：

/*
1. 自定义一个类, 继承 Thread 类. (线程类)
2. 自定义类重写 Thread 类的 run() 方法. 将耗时代码编写到 run() 方法实现体中.
3. 创建一个自定义类的对象.
4. 调用自定义对象的 start() 方法, 启动线程.*/public class ThreadTest2 {// Java虚拟机在程序运行时, 自动启动了一条线程 (主线程)public static void main(String[] args) {// 第一条子线程 ...// 3. 创建一个自定义类的对象.DownloadThread1 downloadThread1 = new DownloadThread1();// 4. 启动downloadThread1.start();// 第二条子线程 ...DownloadThread2 downloadThread2 = new DownloadThread2();downloadThread2.start();// 主线程中运行的代码 ...while (true) {System.out.println("主线程中运行的代码 ...");}}
}

自定义线程类：

public class DownloadThread1 extends Thread {@Overridepublic void run() {while (true) {// 电影 1   (1G -> 5分钟)System.out.println("电影 1 下载中 ...");}}
}public class DownloadThread2 extends Thread {@Overridepublic void run() {while (true) {// 电影 2   (1G -> 5分钟)System.out.println("电影 2 下载中 ...");}}
}

OK 相信我们都看到多线程的现象了，那么接下来几天我们就进入多线程的世界！

那么现在有个小问题，请问植物大战僵尸游戏中，是用了多进程设计程序呢，还是多线程？

Java基础----【异常、线程】相关推荐

Java基础-异常（Exception）处理
Java基础-异常(Exception)处理作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.异常的概述什么是异常?Java代码在运行时期发生的问题就是异常.在Java中,把异 ...
Java基础之线程池
Java基础之线程池转载于:https://www.cnblogs.com/daierge/p/10954228.html
Java基础-异常-throws Exception-抛声明
Java基础-异常-throws Exception-抛声明参考文章: (1)Java基础-异常-throws Exception-抛声明 (2)https://www.cnblogs.com/pl ...
（CZ深入浅出Java基础）线程笔记
这是刘意老师的JAVA基础教程的笔记讲的贼好,附上传送门传智风清扬-超全面的Java基础一.线程的引入 1.多线程概述进程 a.正在运行的程序,是系统进行资源分类和调用的独立单位. b.每个进 ...
java基础之线程（1）
线程是程序中的执行线程.Java 虚拟机允许应用程序并发地运行多个执行线程. 每个线程都有一个优先级,高优先级线程的执行优先于低优先级线程.每个线程都可以或不可以标记为一个守护程序.当某个线程中运行 ...
Java基础拾遗:线程相关问题
在Java中创建线程有两种方法:使用Thread类和使用Runnable接口.要注意的是Thread类也实现了Runnable接口,因此,从Thread类继承的类的实例也可以作为target传入这个构 ...
JAVA基础——异常详解
阅读目录一.异常简介二.try-catch-finally语句三.throw和throws关键字四.java中的异常链五.结束语 JAVA异常与异常处理详解回到顶部一.异常简介什么是异 ...
Java基础 — 异常
异常对象都是派生于Throwable 类的一个实例. 异常层次结构简化示意图: 所有的异常都是由Throwable 继承而来,但在下一层立即分解为两个分支:Error 和 Exception Erro ...
java线程三种方法,Java基础_线程的使用及创建线程的三种方法
线程:线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. 进程:进 ...
Java基础15-多线程
1. 多线程 1.1 概念多线程就是指一个进程中同时有多个线程正在执行. 1.2 程序.进程.线程的区别说起进程,就不得不说下程序.程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态 ...

Java基础----【异常、线程】

主要内容

第一章异常

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 异常注意事项

第三章自定义异常

3.1 概述

3.2 自定义异常的练习

3.3 异常流程的思考 :

第四章多线程

4.1 并发与并行

4.2 线程与进程

4.3 创建线程类

Java基础----【异常、线程】相关推荐

最新文章

热门文章

Java基础----【异常、线程】

主要内容

第一章 异常

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 异常注意事项

第三章 自定义异常

3.1 概述

3.2 自定义异常的练习

3.3 异常流程的思考 :

第四章 多线程

4.1 并发与并行

4.2 线程与进程

4.3 创建线程类

Java基础----【异常、线程】相关推荐

最新文章

热门文章

第一章异常

第二章异常的处理

第三章自定义异常

第四章多线程