Java基础----【异常、线程】-CSDN博客

本文链接：https://blog.csdn.net/CoderBoom/article/details/83720599

本文深入探讨Java中的异常处理机制，包括异常的概念、分类、处理方式及自定义异常，同时介绍了多线程的基本原理，如并发与并行的区别、线程与进程的概念，以及如何创建和管理线程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

主要内容

异常、线程

第一章异常

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 是否为 null
        if (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";

        // StringIndexOutOfBoundsException
        char 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 - catch
        FileReader 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永远会执行。
给大家一张好记的图 , 哈哈

trytrytry

2.5 异常注意事项

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

子父类

public class Person {

    public void introduce() {
        System.out.println("大家好, 我是 Person 类.");
    }
}

public class Student extends Person {

    @Override
    public 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 {

    @Override
    public 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 {
        // 判断, 遍历 names
        for (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: 3
            System.out.println(3);
            String str1 = "";
            System.out.println(str1.toString());
            System.out.println(4);
            String str2 = null;
            System.out.println(str2.toString());        // NullPointerException
            System.out.println(5);
            int num = 10 / 0;
            System.out.println("num = " + num);     // ArithmeticException: / by zero
            System.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 -> 子子类 : FileNotFoundException
        try {
            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 {

    @Override
    public void run() {
        while (true) {
            // 电影 1   (1G -> 5分钟)
            System.out.println("电影 1 下载中 ...");
        }
    }
}

public class DownloadThread2 extends Thread {

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