文章目录

1.1 进程和多线程的概念及线程的优点
1.2 使用多线程

1.2.1 继承 Thread 类
1.2.2 实现 Runnable 接口
1.2.3 实例变量与线程安全
1.2.4 留意 i-- 与 System.out.println() 的异常

1.3 currentThread() 方法
1.4 isAlive() 方法
1.5 sleep() 方法
1.6 getId() 方法
1.7 停止线程

1.7.1 停止不了的线程
1.7.2 判断线程是否是停止状态
1.7.3 能停止的线程——异常法
1.7.4 在沉睡中停止
1.7.5 能停止的线程——暴力停止
1.7.6 方法 stop() 与 java.lang.ThreadDeath 异常
1.7.7 释放锁的不良后果
1.7.8 使用 return 停止线程

1.8 暂停线程

1.8.1 suspend 与 resume 方法的使用
1.8.2 suspend 和 resume 方法的缺点——独占
1.8.3 suspend 和 resume 方法的缺点——不同步

1.9 yield 方法
1.10 线程的优先级

1.10.1 线程优先级的继承性
1.10.2 优先级具有规则性
1.10.3 优先级具有随机性
1.10.4 看谁运行的快

1.11 守护线程

本章主要介绍 Thread 类中的核心方法，Thread 类的核心方法较多，读者应该着重掌握如下关键技术点：

线程的启动
如何使线程暂停
如何使线程停止
线程的优先级
线程安全相关的问题

1.1 进程和多线程的概念及线程的优点

进程是受操作系统管理的基本运行单元
线程是在进程中独立运行的子任务

比如：QQ.exe 这个进程运行时就有很多子任务（好友视频，下载文件，发送表情）在同时运行，其中每一项任务都可以理解成是线程在工作
多线程的优点：可以最大限度的利用 CPU 的空闲时间来处理其它的任务，提高 CPU 的利用率

比如：一边让操作系统处理正在由打印机打印的数据，一边使用 Word 编辑文档，而 CPU 在这些任务间不停地切换，由于切换速度非常快，给使用者的感受就是这些任务似乎在同时运行。

以下是单任务运行环境的模型图：

在这里插入图片描述

在单任务运行环境中，任务 1 和任务 2 是两个完全独立，互不相关的任务，任务 1 是在等待远程服务器返回数据，这时 CPU 一直处于等待状态，而任务 2 必须在任务 1 运行结束后才可以运行，虽然任务 2 执行时间仅有 1 秒，但却有 10 秒的等待时间，系统运行效率大幅降低
单任务运行环境的特点就是排队执行，也就是同步
单任务运行环境的缺点，即 CPU 利用率大幅降低

以下是多任务运行环境的模型图：

在这里插入图片描述

在多任务运行环境中，CPU 完全可以在任务 1 和任务 2 之间来回切换，使任务 2 不必等到 10 秒再运行，系统的运行效率大大得到提升
使用多线程就是在使用异步

1.2 使用多线程

一个进程正在运行时，至少会有一个线程正在运行，比如调用 main 方法的线程就是这样的：

public class Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果

main

分析：这说明一个叫 main 的线程正在执行 main() 方法中的代码

1.2.1 继承 Thread 类

实现多线程编程的方式主要有两种，一种是继承 Thread 类，一种是实现 Runnable 接口

接下来我们看一下继承 Thread 类实现多线程编程：

创建一个自定义的线程类

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread");
    }
}

测试类

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("运行结束");
    }
}

运行结果

运行结束
MyThread

分析：MyThread 类的 run 方法执行的时间比较晚，这也说明使用多线程技术时，代码的运行结果与代码的执行顺序或调用顺序是无关的。线程是一个子任务，CPU 以随机的方式来调用线程中的 run 方法。

下面演示线程调用的随机性：

创建一个自定义的线程类

public class MyThread2 extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 10; i++) {
            int time = (int) (Math.random() * 1000);
            try {
                Thread.sleep(time);
                System.out.println("run="+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类

public class MyThread2Test {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        myThread2.setName("myThread2");
        myThread2.start();
        for (int i = 0; i < 10; i++) {
            int time = (int) (Math.random() * 1000);
            try {
                Thread.sleep(time);
                System.out.println("main=" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果

run=myThread2
main=main
run=myThread2
run=myThread2
main=main
run=myThread2
run=myThread2
main=main
run=myThread2
main=main
run=myThread2
run=myThread2
main=main
run=myThread2
run=myThread2
main=main
main=main
main=main
main=main
main=main

分析：为了展示出线程的调用具有随机特性，所以使用随机数的形式来使线程挂起，从而表现出 CPU 执行哪个线程具有不确定性

注意：Thread 类中的 start() 方法的作用是通知 ”线程规划器“ 此线程已经准备就绪，等待调用线程对象的 run() 方法，具有异步效果。如果调用 thread.run() 就是同步了，那么此线程对象并不交给 ”线程规划器“ 来进行处理，而是由 main 主线程来调用 run() 方法，也就是说要等到 run() 方法执行完才可以执行后面的代码

下面演示 start() 方法的执行顺序不代表线程的启动顺序：

创建一个自定义的线程类

public class MyThread3 extends Thread {
    private int i;

    public MyThread3(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(i);
        super.run();
    }
}

测试类

public class MyThread3Test {
    public static void main(String[] args) {
        List<MyThread3> myThread3List = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            myThread3List.add(new MyThread3(i));
        }
        for (int i = 0; i < 10; i++) {
            myThread3List.get(i).start();
        }
    }
}

运行结果

1.2.2 实现 Runnable 接口

如果想要创建的线程类已经有一个父类了，这是就不能再继承自 Thread 类了，因为 Java 不支持多继承，所以就需要实现 Runnable 接口来应对这样的情况了

Thread 类有两个构造函数 Thread(Runnable target) 和 Thread(Runnable target, String name)，说明构造函数支持传入一个 Runnable 接口的对象。

下面看一下实现 Runnable 接口来实现多线程编程：

创建一个自定义的线程类

public class MyThread4 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread4");
    }
}

测试类

public class MyThread4Test {
    public static void main(String[] args) {
        MyThread4 myThread4 = new MyThread4();
        Thread thread = new Thread(myThread4);
        thread.start();
        System.out.println("运行结束");
    }
}

运行结果

运行结束
MyThread4

另外要说明的是，Thread 类也实现了 Runnable 接口

public class Thread implements Runnable {

这也就意味着 Thread(Runnable target) 不光可以传入 Runnable 对象，还可以传入一个 Thread 类的对象，这样做完全可以将一个 Thread 对象中的 run() 方法交给其它的线程进行调用

1.2.3 实例变量与线程安全

自定义线程类中的实例变量针对其他线程可以有共享和不共享之分

不共享的情况

在这里插入图片描述

下面通过一个示例来看一下数据不共享的情况：

创建一个自定义的线程类

public class MyThread5 extends Thread {
    private int count = 5;

    public MyThread5(String name) {
        super();
        this.setName(name);
    }

    @Override
    public void run() {
        super.run();
        while (count > 0) {
            count--;
            System.out.println("由" + this.currentThread().getName() + "计算，count = " + count);
        }
    }
}

测试类

public class MyThread5Test {
    public static void main(String[] args) {
        MyThread5 a = new MyThread5("A");
        MyThread5 b = new MyThread5("B");
        MyThread5 c = new MyThread5("C");
        a.start();
        b.start();
        c.start();

    }
}

运行结果

由B计算，count = 4
由A计算，count = 4
由A计算，count = 3
由B计算，count = 3
由B计算，count = 2
由A计算，count = 2
由B计算，count = 1
由C计算，count = 4
由B计算，count = 0
由A计算，count = 1
由A计算，count = 0
由C计算，count = 3
由C计算，count = 2
由C计算，count = 1
由C计算，count = 0

分析：一共创建了 3 个线程，每个线程都有各自的 count 变量，自己减少自己的 count 变量的值，这样情况就是变量不共享

共享数据的情况

在这里插入图片描述

共享数据的情况就是多个线程可以访问同一个变量，比如在实现投票功能的软件时，多个线程可以同时处理同一个人的票数

下面通过一个示例来看一下数据共享的情况：

创建一个自定义的线程类

public class MyThread6 extends Thread {
    private int count = 5;

    @Override
    public void run() {
        super.run();
        count--;
        System.out.println("由" + this.currentThread().getName() + "计算，count = " + count);
    }
}

测试类

public class MyThread6Test {
    public static void main(String[] args) {
        MyThread6 myThread6 = new MyThread6();

        Thread a = new Thread(myThread6, "A");
        Thread b = new Thread(myThread6, "B");
        Thread c = new Thread(myThread6, "C");
        Thread d = new Thread(myThread6, "D");
        Thread e = new Thread(myThread6, "E");

        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

运行结果

由B计算，count = 3
由A计算，count = 3
由C计算，count = 2
由D计算，count = 1
由E计算，count = 0

分析：线程 A 和线程 B 打印出的 count 值都是 3，说明 A 和 B 同时对 count 进行了处理，这就产生了 ”非线程安全“ 问题。“非线程安全” 主要是指多个线程对同一个对象中的同一个实例变量进行操作时，会出现值被更改、值不同步的情况，进而影响到程序的执行流程。

但我们想要得到的打印结果是依次递减的，该怎么解决非线程安全问题呢？ 这时就需要使多个线程之间进行同步，也就是用按顺序排队的方式进行减 1 操作。更改后的代码如下：

创建一个自定义的线程类

public class MyThread7 extends Thread {
    private int count = 5;

    @Override
    synchronized public void run() {
        super.run();
        count--;
        System.out.println("由" + this.currentThread().getName() + "计算，count = " + count);
    }
}

测试类

public class MyThread7Test {
    public static void main(String[] args) {
        MyThread7 myThread7 = new MyThread7();

        Thread a = new Thread(myThread7, "A");
        Thread b = new Thread(myThread7, "B");
        Thread c = new Thread(myThread7, "C");
        Thread d = new Thread(myThread7, "D");
        Thread e = new Thread(myThread7, "E");

        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

运行结果

由A计算，count = 4
由B计算，count = 3
由C计算，count = 2
由D计算，count = 1
由E计算，count = 0

分析：在 run() 方法前加入 synchronized 关键字，使多个线程在执行 run() 方法时，以排队的方式进行处理。 当一个线程调用 run() 方法前，先判断 run() 方法有没有被上锁，如果上锁，说明有其他线程正在调用 run() 方法，必须等其他线程对 run() 方法调用结束后才可以执行 run() 方法。这样也就实现了排队调用 run() 方法的目的了。

synchronized 可以在任意对象及方法上加锁，而加锁的这段代码称为 ”互斥区“ 或 ”临界区“。

1.2.4 留意 i-- 与 System.out.println() 的异常

System.out.println() 方法内部是同步的

public void println(String x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

System.out.println() 与 i-- 联合使用时还是会产生 ”非线程安全问题“，下面通过一个示例来看一下：

创建一个自定义的线程类

public class MyThread8 extends Thread {
    private int i = 5;

    @Override
    public void run() {
        super.run();
        System.out.println("i = " + (i--) + "   threadName = " + this.currentThread().getName());
    }
}

测试类

public class MyThread8Test {
    public static void main(String[] args) {
        MyThread8 myThread8 = new MyThread8();
        Thread t1 = new Thread(myThread8);
        Thread t2 = new Thread(myThread8);
        Thread t3 = new Thread(myThread8);
        Thread t4 = new Thread(myThread8);
        Thread t5 = new Thread(myThread8);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

运行结果

i = 5   threadName = Thread-2
i = 3   threadName = Thread-4
i = 2   threadName = Thread-5
i = 4   threadName = Thread-3
i = 5   threadName = Thread-1

分析：虽然 System.out.println() 方法内部是同步的，但 i-- 操作却是在进入 println() 之前发生的，所以还是会产生 ”非线程安全问题“。为了防止 ”非线程安全问题“ 的发生，还是应该继续使用同步方法

1.3 currentThread() 方法

currentThread() 方法可返回代码块正在被哪个线程调用的信息

下面通过一个示例进行说明：

创建一个自定义的线程类

public class MyThread9 extends Thread {
    public MyThread9() {
        System.out.println("构造方法的打印：" + Thread.currentThread().getName());
    }
    
    @Override
    public void run() {
        super.run();
        System.out.println("run 方法的打印：" + Thread.currentThread().getName());
    }
}

测试类

public class MyThread9Test {
    public static void main(String[] args) {
        MyThread9 myThread9 = new MyThread9();
        myThread9.start();
    }
}

运行结果

构造方法的打印：main
run 方法的打印：Thread-0

分析：MyThread 类的构造函数是被 main 线程调用的，而 run 方法是被名称为 Thread-0 的线程调用的

下面再看一个比较复杂的实例：

创建一个自定义的线程类

public class MyThread10 extends Thread {
    public MyThread10() {
        System.out.println("MyThread10---begin");
        // Thread.currentThread().getName() 指的是调用 MyThread10 这个线程类的线程的名称
        System.out.println("Thread.currentThread().getName():" + Thread.currentThread().getName());
        // this.getName() 指的是 MyThread10 这个线程类的名称
        System.out.println("this.getName():" + this.getName());
        System.out.println("MyThread10---end");
    }

    @Override
    public void run() {
        super.run();
        System.out.println("run---begin");
        System.out.println("Thread.currentThread().getName():" + Thread.currentThread().getName());
        System.out.println("this.getName():" + this.getName());
        System.out.println("run---end");
    }
}

测试类

public class MyThread10Test {
    public static void main(String[] args) {
        MyThread10 myThread10 = new MyThread10();
        System.out.println("---------");
        Thread thread = new Thread(myThread10,"A");
        thread.start();
    }
}

运行结果

MyThread10---begin
Thread.currentThread().getName():main
this.getName():Thread-0
MyThread10---end
---------
run---begin
Thread.currentThread().getName():A
this.getName():Thread-0
run---end

1.4 isAlive() 方法

isAlive() 方法的功能是判断当前的线程是否处于活动状态，活动状态就是线程已经启动且尚未终止

下面通过一个示例进行说明：

创建一个自定义的线程类

public class MyThread11 extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("run = " + this.isAlive());
    }
}

测试类

public class MyThread11Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread11 myThread11 = new MyThread11();
        System.out.println("begin = " + myThread11.isAlive());
        myThread11.start();
        Thread.sleep(1000);
        System.out.println("end = " + myThread11.isAlive());
    }
}

运行结果

begin = false
run = true
end = false

分析：begin = false 是因为 myThread11 线程还未启动，end = false 是因为 myThread11 线程已经终止

在使用 isAlive() 方法时，如果将线程对象以构造参数的方式传递给 Thread 对象进行 start() 启动，运行的结果和前面的示例是有差异的。造成差异的主要原因还是来自于 Thread.currentThread() 和 this 的差异，下面通过一个示例进行说明：

创建一个自定义的线程类

public class MyThread12 extends Thread {
    public MyThread12() {
        System.out.println("MyThread12---begin");
        // Thread.currentThread().getName() 指的是调用 MyThread10 这个线程类的线程的名称
        System.out.println("Thread.currentThread().getName():" + Thread.currentThread().getName());
        // Thread.currentThread().isAlive() 指的是调用 MyThread10 这个线程类的线程是否处于活动状态
        System.out.println("Thread.currentThread().isAlive():" + Thread.currentThread().isAlive());
        // this.getName() 指的是 MyThread10 这个线程类的名称
        System.out.println("this.getName():" + this.getName());
        // this.isAlive() 指的是 MyThread10 这个线程类是否处于活动状态
        System.out.println("this.isAlive():" + this.isAlive());
        System.out.println("MyThread12---end");
    }

    @Override
    public void run() {
        super.run();
        System.out.println("run---begin");
        System.out.println("Thread.currentThread().getName():" + Thread.currentThread().getName());
        System.out.println("Thread.currentThread().isAlive():" + Thread.currentThread().isAlive());
        System.out.println("this.getName():" + this.getName());
        System.out.println("this.isAlive():" + this.isAlive());
        System.out.println("run---end");
    }
}

测试类

public class MyThread12Test {
    public static void main(String[] args) {
        MyThread12 myThread12 = new MyThread12();
        System.out.println("---------");
        Thread thread = new Thread(myThread12, "A");
        thread.start();
    }
}

运行结果

MyThread12---begin
Thread.currentThread().getName():main
Thread.currentThread().isAlive():true
this.getName():Thread-0
this.isAlive():false
MyThread12---end
---------
run---begin
Thread.currentThread().getName():A
Thread.currentThread().isAlive():true
this.getName():Thread-0
this.isAlive():false
run---end

1.5 sleep() 方法

sleep() 方法的作用是在指定的毫秒数内让当前 ”正在执行的线程” 休眠（暂停执行）。这个 ”正在执行的线程” 是指 this.currentThread() 返回的线程。

下面通过一个示例来说明：

创建一个自定义的线程类

public class MyThread13 extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            System.out.println("run threadName = " + this.currentThread().getName() + " begin time = " + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("run threadName = " + this.currentThread().getName() + " end time = " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试类

public class MyThread13Test {
    public static void main(String[] args) {
        System.out.println("begin time = " + System.currentTimeMillis());
        MyThread13 myThread13 = new MyThread13();
        myThread13.run();
        System.out.println("end time = " + System.currentTimeMillis());
    }
}

运行结果

begin time = 1573470507836
run threadName = main begin time = 1573470507837
run threadName = main end time = 1573470509838
end time = 1573470509838

分析：上面测试类中是直接调用 myThread13.run() 方法，也就是由 main 线程来调用 run() 方法，从运行结果可以看到在 run() 方法中 main 线程暂停了 2000 毫秒

接下来看看使用 start() 方法启动 myThread13 线程：

测试类

public class MyThread13_2 {
    public static void main(String[] args) {
        System.out.println("begin time = " + System.currentTimeMillis());
        MyThread13 myThread13 = new MyThread13();
        myThread13.start();
        System.out.println("end time = " + System.currentTimeMillis());
    }
}

运行结果

begin time = 1573470976618
end time = 1573470976620
run threadName = Thread-0 begin time = 1573470976621
run threadName = Thread-0 end time = 1573470978621

分析：由于 main 线程和 myThread13 线程是异步执行的，所以首先执行的是 main 线程打印的 begin time 和 end time，而 myThread13 线程是随后运行的，从运行结果可以看到在 run() 方法中 myThread13 线程暂停了 2000 毫秒

1.6 getId() 方法

getId() 方法的作用是取得线程的唯一标识。

下面通过一个示例来说明：

创建一个测试类

 public class Test2 {
     public static void main(String[] args) {
         System.out.println(Thread.currentThread().getName());
         System.out.println(Thread.currentThread().getId());
     }
 }

运行结果

main
1

分析：从运行结果来看，说明正在执行 main() 方法中代码的线程名称为 main，线程 id 值为 1

1.7 停止线程

停止一个线程意味着在线程处理完任务之前停掉正在做的操作，也就是放弃当前操作。

在 Java 中有以下三种方法可以终止正在运行的线程：

使用退出标志，使线程正常退出，也就是当 run() 方法完成后线程终止
使用 stop() 方法强行终止线程，已废弃，不推荐使用
使用 interrupt() 方法中断线程，经常使用

1.7.1 停止不了的线程

接下来会使用 interrupt() 方法，但这个方法不会真的停止线程，只是在当前线程中打了一个停止的标记

下面通过一个示例来说明：

创建一个自定义的线程类

public class MyThread14 extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 500000; i++) {
            System.out.println(i);
        }
    }
}

测试类

public class MyThread14Test {
    public static void main(String[] args) {
        try {
            MyThread14 myThread14 = new MyThread14();
            myThread14.start();
            Thread.sleep(1000);
            myThread14.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

分析：从运行结果来看，调用 interrupt() 方法并没有停止线程，那该如何停止线程呢？

1.7.2 判断线程是否是停止状态

在介绍如何如何停止线程前，先来看一下如何判断线程的状态是否是停止的。

Thread 类中提供了两种方法：

this.interrupted()：测试当前线程是否已经是中断状态，当前线程是指运行 this.interrupted() 方法的线程，执行后具有将状态标志清除为 false 的功能
this.isInterrupted()：测试线程 Thread 对象是否已经是中断状态，但不清除状态标志

下面通过一个示例来演示 interrupted() 方法的使用：

创建一个自定义的线程类

public class MyThread15 extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 50000; i++) {
            System.out.println(i);
        }
    }
}

测试类

public class MyThread15Test {
    public static void main(String[] args) {
        try {
            MyThread15 myThread15 = new MyThread15();
            myThread15.start();
            // 让 main 线程休眠 0.5 秒，这样线程规划器会先执行 myThread15 线程
            Thread.sleep(500);
            myThread15.interrupt();
            System.out.println("是否停止1 = " + myThread15.interrupted());
            System.out.println("是否停止2 = " + myThread15.interrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

运行结果

...
40292
40293
40294
40295
是否停止1 = false
40296
40297
...
40803
40804
40805
是否停止2 = false
40806
40807
40808
40809
...

分析：

我们在测试类中调用了以下代码，来停止 myThread15 线程：

myThread15.interrupt();

但在后面又使用了以下代码，来判断当前线程是否停止：

System.out.println("是否停止1 = " + myThread15.interrupted());
System.out.println("是否停止2 = " + myThread15.interrupted());

但打印结果说明当前线程并未停止，再看看 interrupted() 方法的解释：测试当前线程是否已经是中断状态，当前线程是指运行 this.interrupted() 方法的线程

这个当前线程是 main 线程，它从未中断过，所以打印结果是两个 false

接下来让 main 线程产生中断，再看看：

创建测试类

public class Test3 {
    public static void main(String[] args) {
        Thread.currentThread().interrupt();
        System.out.println("是否停止1 = " + Thread.interrupted());
        System.out.println("是否停止2 = " + Thread.interrupted());
    }
}

运行结果

是否停止1 = true
是否停止2 = false

分析：第一次调用 interrupted() 判断当前线程已经是中断状态了，然后清除了状态标志，所以第二次调用 interrupted() 方法的返回值是 false

介绍完 interrupted() 方法，下面通过一个示例来演示 isInterrupted() 方法的使用：

创建测试类

public class MyThread15Test_2 {
    public static void main(String[] args) {
        try {
            MyThread15 myThread15 = new MyThread15();
            myThread15.start();
            // 让 main 线程休眠 0.5 秒，这样线程规划器会先执行 myThread15 线程
            Thread.sleep(500);
            myThread15.interrupt();
            System.out.println("是否停止1 = " + myThread15.isInterrupted());
            System.out.println("是否停止2 = " + myThread15.isInterrupted());
        } catch (InterruptedException e) {
         e.printStackTrace();
        }
 }
}

运行结果

...
48254
48255
48256
48257
是否停止1 = true
是否停止2 = true
48258
48259
48260
...

分析：从打印结果上来看，测试 myThread15 线程已经是中断状态了，而且 isInterrupted() 方法并不清除状态标志，所以打印了两个 true

1.7.3 能停止的线程——异常法

有了前面学习的知识，就可以在 for 语句中判断一下线程是否是中断状态了，如果是中断状态，则后面的代码不再运行即可。

下面通过一个示例来演示异常法停止线程：

创建一个自定义的线程类

public class MyThread16 extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            for (int i = 0; i < 50000; i++) {
                // 如果是中断状态就不再执行后面的代码了
                if (this.interrupted()) {
                    System.out.println("我要退出了...");
                    throw new InterruptedException();
                }
                System.out.println(i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试类

public class MyThread16Test {
    public static void main(String[] args) {
        try {
            MyThread16 myThread16 = new MyThread16();
            myThread16.start();
            Thread.sleep(500);
            myThread16.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

...
41332
41333
41334
41335
41336
41337
41338
我要退出了...
java.lang.InterruptedException
	at MyThread16.run(MyThread16.java:9)

1.7.4 在沉睡中停止

如果线程在 sleep() 状态下停止线程，会是什么效果呢？

下面通过一个示例来演示：

创建一个自定义的线程类

public class MyThread17 extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            System.out.println("begin");
            Thread.sleep(100000);
            System.out.println("end");
        } catch (InterruptedException e) {
            System.out.println("线程沉睡中被中断，进入 catch !" + " this.interrupted() = "+this.interrupted());
            e.printStackTrace();
        }
    }
}

测试类

public class MyThread17Test {
    public static void main(String[] args) {
        try {
            MyThread17 myThread17 = new MyThread17();
            myThread17.start();
            Thread.sleep(500);
            myThread17.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

begin
线程沉睡中被中断，进入 catch ! this.interrupted() = false
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at MyThread17.run(MyThread17.java:7)

分析：从打印结果上来看，如果在 sleep 状态下停止某一线程，会进入 catch 语句，并清除停止状态值，使之变成 false

前面一个实验是先 sleep 然后再停止线程，接下来我们看看先停止线程再 sleep 会怎样，下面通过一个示例来演示：

创建一个自定义的线程类

public class MyThread18 extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            for (int i = 0; i < 50000; i++) {
                System.out.println(i);
            }
            System.out.println("begin");
            Thread.sleep(100000);
            System.out.println("end");
        } catch (InterruptedException e) {
            System.out.println("线程先被中断，再遇到 sleep ,进入 catch !" + " this.interrupted() = " + this.interrupted());
            e.printStackTrace();
        }
    }
}

测试类

public class MyThread18Test {
    public static void main(String[] args) {
        MyThread18 myThread18 = new MyThread18();
        myThread18.start();
        myThread18.interrupt();
    }
}

运行结果

49997
49998
49999
begin
线程先被中断，再遇到 sleep ,进入 catch ! this.interrupted() = false
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at MyThread18.run(MyThread18.java:10)

1.7.5 能停止的线程——暴力停止

使用 stop() 方法停止线程是非常暴力的，下面通过一个示例来演示：

创建一个自定义的线程类

public class MyThread19 extends Thread {
    private int i = 0;

    @Override
    public void run() {
        super.run();
        try {
            while (true) {
                i++;
                System.out.println(i);
                sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("进入了 catch() 中");
            e.printStackTrace();
        }

    }
}

测试类

public class MyThread19Test {
    public static void main(String[] args) {
        try {
            MyThread19 myThread19 = new MyThread19();
            myThread19.start();
            Thread.sleep(8000);
            myThread19.stop();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

1.7.6 方法 stop() 与 java.lang.ThreadDeath 异常

调用 stop() 方法时会抛出 java.lang.ThreadDeath 异常，但在通常的情况下，此异常不需要显示地捕获。

下面通过一个示例来演示：

创建一个自定义的线程类

public class MyThread20 extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            this.stop();
        } catch (ThreadDeath e) {
            System.out.println("进入了 catch() 中");
            e.printStackTrace();
        }
    }
}

测试类

public class MyThread20Test {
    public static void main(String[] args) {
        MyThread20 myThread20 = new MyThread20();
        myThread20.start();
    }
}

运行结果

进入了 catch() 中
java.lang.ThreadDeath
	at java.lang.Thread.stop(Thread.java:850)
	at MyThread20.run(MyThread20.java:6)

1.7.7 释放锁的不良后果

stop() 方法已经被作废，原因如下：

如果强制让线程停止，则有可能使一些清洁性的工作得不到完成
对锁定的对象进行了 ”解锁“，导致数据得不到同步的处理，出现数据不一致的问题

下面通过一个示例来演示 stop() 方法造成数据不一致的示例：

创建一个对象，其中 setUsernameAndPassword 方法上锁

public class SynchronizedObject {
    private String username = "a";
    private String password = "aa";

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    synchronized public void setUsernameAndPassword(String username, String password) {
        try {
            this.username = username;
            Thread.sleep(10000);
            this.password = password;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建一个自定义的线程类

public class MyThread21 extends Thread {
    private SynchronizedObject synchronizedObject;

    public MyThread21(SynchronizedObject synchronizedObject) {
        this.synchronizedObject = synchronizedObject;
    }

    @Override
    public void run() {
        super.run();
        synchronizedObject.setUsernameAndPassword("b","bb");
    }
}

测试类

public class MyThread21Test {
    public static void main(String[] args) {
        try {
            SynchronizedObject synchronizedObject = new SynchronizedObject();
            MyThread21 myThread21 = new MyThread21(synchronizedObject);
            myThread21.start();
            Thread.sleep(500);
            myThread21.stop();
            System.out.println(synchronizedObject.getUsername() + " " +synchronizedObject.getPassword());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

b aa

1.7.8 使用 return 停止线程

将方法 interrupt() 和 return 结合使用也能实现停止线程的效果，不过还是建议使用 ”抛异常“ 法来实现线程的停止，因为 catch 块可以对异常的信息进行相关的处理，而且使用异常流能更方便地控制程序的运行流程，不至于代码中出现很多个 return 造成污染

下面通过一个示例来演示使用 return 停止线程：

创建一个自定义的线程类

public class MyThread22 extends Thread {
    private int i = 0;
    @Override
    public void run() {
        super.run();
        while (true) {
            if(this.isInterrupted()){
                System.out.println("退出了");
                return;
            }
            System.out.println(i);
            i++;
        }
    }
}

测试类

public class MyThread22Test {
    public static void main(String[] args) {
        try {
            MyThread22 myThread22 = new MyThread22();
            myThread22.start();
            Thread.sleep(500);
            myThread22.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

1.8 暂停线程

暂停线程意味着此线程还可以恢复运行。在 Java 多线程中，可以使用 suspend() 方法暂停线程，使用 resume() 方法恢复线程的执行。这两个方法已经是过期作废的方法了

1.8.1 suspend 与 resume 方法的使用

下面通过一个示例来演示 suspend 与 resume 方法的使用：

创建一个自定义的线程类

public class MyThread23 extends Thread {
    private int i = 0;

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        super.run();
        while (true) {
            i++;
        }
    }
}

测试类

public class MyThread23Test {
    public static void main(String[] args) {
        try {
            // 创建线程
            MyThread23 myThread23 = new MyThread23();
            // 启动线程
            myThread23.start();
            Thread.sleep(500);
            // 暂停线程
            myThread23.suspend();

            // A 段
            System.out.println("A = " + System.currentTimeMillis() + " i = " + myThread23.getI());
            Thread.sleep(500);
            System.out.println("A = " + System.currentTimeMillis() + " i = " + myThread23.getI());

            // 恢复线程
            myThread23.resume();
            Thread.sleep(500);
            // 暂停线程
            myThread23.suspend();

            // B 段
            System.out.println("B = " + System.currentTimeMillis() + " i = " + myThread23.getI());
            Thread.sleep(500);
            System.out.println("B = " + System.currentTimeMillis() + " i = " + myThread23.getI());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

A = 1573647074155 i = 220277857
A = 1573647074655 i = 220277857
B = 1573647075156 i = 469660276
B = 1573647075656 i = 469660276

分析：从打印结果上来看，线程的确被暂停了，而且还可以恢复成运行的状态

1.8.2 suspend 和 resume 方法的缺点——独占

在使用 suspend 和 resume 方法时，如果使用不当，极易造成公共的同步对象的独占，使得其他线程无法访问公共的同步对象。

下面通过一个示例来演示独占锁的情况：

创建一个自定义的线程类

public class MyThread24 extends Thread {
    private int count = 5;

    @Override
    synchronized public void run() {
        super.run();
        count--;
        System.out.println("由" + this.currentThread().getName() + "计算，count = " + count);
        if (this.currentThread().getName() == "A") {
            // A 线程永远 suspend 了
            Thread.currentThread().suspend();
        }
    }
}

测试类

public class MyThread24Test {
    public static void main(String[] args) {
        try {
            MyThread24 myThread24 = new MyThread24();
            Thread a = new Thread(myThread24, "A");
            a.start();
            Thread.sleep(500);
            Thread b = new Thread(myThread24, "B");
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

运行结果

由A计算，count = 4

分析：A 线程先在 run() 方法中被永远暂停了，然后 B 线程就不能进入 run() 方法了，因为 run() 方法被 A 线程独占了

下面通过一个示例来演示另一种独占锁的情况：

创建一个自定义的线程类

public class MyThread25 extends Thread {
    private int i = 0;
    @Override
    public void run() {
        super.run();
        while (true) {
            i++;
//            System.out.println(i);
        }
    }
}

测试类

public class MyThread25Test {
    public static void main(String[] args) {
        try {
            MyThread25 myThread25 = new MyThread25();
            myThread25.start();
            Thread.sleep(500);
            myThread25.suspend();
            System.out.println("main end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

main end

接下来把 MyThread25 中的注释去掉，再次运行，运行结果如下
```
...
41172
41173
41174
41175
41176
```

分析：第二次运行控制台没有打印 main end，出现这样的情况的原因是，当程序运行到 println() 方法内部时，同步锁未被释放。

之前讲过，System.out.println() 方法内部是同步的，源代码如下：

public void println(String x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

这导致 PrintStream 对象的 println() 方法一直呈暂停状态，并且锁未释放，所以 main() 方法中的代码 System.out.println(“main end”); 迟迟不能打印。

1.8.3 suspend 和 resume 方法的缺点——不同步

在使用 suspend 和 resume 方法时也容易出现因为线程的暂停而导致数据不同步的情况。

下面通过一个示例来演示数据不同步的情况：

创建一个自定义的实体类

public class MyObject {
    private String username = "a";
    private String password = "aa";

    public void setUsernameAndPassword(String username, String password) {
        this.username = username;
        if (Thread.currentThread().getName() == "A"){
            // 线程暂停了
            Thread.currentThread().suspend();
        }
        this.password = password;
    }

    public void printUsernameAndPassword() {
        System.out.println(this.username + " " + this.password);
    }
}

测试类

public class MyObjectTest {
    public static void main(String[] args) {
        try {
            MyObject myObject = new MyObject();
            Thread thread1 = new Thread() {
                @Override
                public void run() {
                    super.run();
                    myObject.setUsernameAndPassword("b","bb");
                }
            };
            thread1.setName("A");
            thread1.start();
            Thread.sleep(500);
            Thread thread2 = new Thread(){
                @Override
                public void run() {
                    super.run();
                    myObject.printUsernameAndPassword();
                }
            };
            thread2.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

b aa

1.9 yield 方法

yield() 方法的作用是放弃当前的 CPU 资源，将它让给其它的任务去占用 CPU 执行时间。但放弃的时间不确定，有可能刚刚放弃，马上又获得 CPU 时间片。

下面通过一个示例来演示 yield 方法的使用：

创建一个自定义的线程类

public class MyThread26 extends Thread {
    @Override
    public void run() {
        super.run();
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 5000000; i++) {
//            Thread.yield();
            count += i;
        }
        System.out.println(count);
        long endTime = System.currentTimeMillis();
        System.out.println("用时：" + (endTime - beginTime) + "毫秒");
    }
}

测试类

public class MyThread26Test {
    public static void main(String[] args) {
        MyThread26 myThread26 = new MyThread26();
        myThread26.start();
    }
}

运行结果

1642668640
用时：5毫秒

接下来把 MyThread26 中的注释取消，再次运行，运行结果如下：
```
1642668640
用时：4726毫秒
```

分析：显然，第二次运行，将 CPU 让给其他资源导致速度变慢了

1.10 线程的优先级

在操作系统中，线程可以划分优先级，优先级高的线程得到的 CPU 资源较多，也就是 CPU 优先执行优先级较高的线程对象中的任务。

设置线程优先级有助于帮 “线程规划器” 确定在下一次选择哪个线程来优先执行。

设置线程的优先级使用 setPriority() 方法，此方法源码如下：

public final void setPriority(int newPriority) {
    ThreadGroup g;
    checkAccess();
    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();
    }
    if((g = getThreadGroup()) != null) {
        if (newPriority > g.getMaxPriority()) {
            newPriority = g.getMaxPriority();
        }
        setPriority0(priority = newPriority);
    }
}

在 Java 中，线程的优先级分为 1-10 这 10 个等级，如果小于 1 或大于 10，则 JDK 抛出异常 throw new IllegalArgumentException()

1.10.1 线程优先级的继承性

在 Java 中，线程的优先级具有继承性，比如 A 线程启动 B 线程，则 B 线程的优先级与 A 是一样的。

下面通过一个示例来演示：

创建两个自定义的线程类

public class MyThread27 extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread27 priority: " + this.getPriority());
        MyThread27_2 myThread27_2 = new MyThread27_2();
        myThread27_2.start();
    }
}

public class MyThread27_2 extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread27_2 priority: " + this.getPriority());
    }
}

测试类

public class MyThread27Test {
    public static void main(String[] args) {
        System.out.println("main begin priority: "+Thread.currentThread().getPriority());
//        Thread.currentThread().setPriority(6);
        System.out.println("main end priority: "+Thread.currentThread().getPriority());
        MyThread27 myThread27 = new MyThread27();
        myThread27.start();
    }
}

运行结果

main begin priority: 5
main end priority: 5
MyThread27 priority: 5
MyThread27_2 priority: 5

接下来把 MyThread27Test 中的注释取消，再次运行，运行结果如下：

main begin priority: 5
main end priority: 6
MyThread27 priority: 6
MyThread27_2 priority: 6

分析：显然，第二次运行优先级被更改后，依然被继承了

1.10.2 优先级具有规则性

线程的优先级具有一定的规则性，也就是 CPU 尽量将执行资源让给优先级比较高的线程。

下面通过一个示例来演示：

创建两个自定义的线程类

public class MyThread28 extends Thread {
    @Override
    public void run() {
        super.run();
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 100000000; i++) {
            count += i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("MyThread28 用时：" + (endTime - beginTime) + "毫秒");
    }
}

public class MyThread28_2 extends Thread {
    @Override
    public void run() {
        super.run();
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 50000000; i++) {
            count += i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("MyThread28_2 用时：" + (endTime - beginTime) + "毫秒");
    }
}

测试类

public class MyThread28Test {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyThread28 myThread28 = new MyThread28();
            myThread28.setPriority(10);
            myThread28.start();
            MyThread28_2 myThread28_2 = new MyThread28_2();
            myThread28_2.setPriority(1);
            myThread28_2.start();
        }
    }
}

运行结果

MyThread28 用时：44毫秒
MyThread28 用时：45毫秒
MyThread28 用时：47毫秒
MyThread28 用时：39毫秒
MyThread28_2 用时：26毫秒
MyThread28_2 用时：31毫秒
MyThread28 用时：39毫秒
MyThread28_2 用时：58毫秒
MyThread28_2 用时：22毫秒
MyThread28_2 用时：22毫秒

分析：从打印结果上来看，高优先级的线程总是大部分先执行完，但不代表高优先级的线程全部先执行完

当线程优先级的等级差距很大时，谁先执行完和代码的调用顺序无关，为了验证这一结论，继续实验：

测试类

public class MyThread28Test_2 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyThread28 myThread28 = new MyThread28();
            myThread28.setPriority(1);
            myThread28.start();
            MyThread28_2 myThread28_2 = new MyThread28_2();
            myThread28_2.setPriority(10);
            myThread28_2.start();
        }
    }
}

运行结果

MyThread28_2 用时：27毫秒
MyThread28_2 用时：26毫秒
MyThread28_2 用时：28毫秒
MyThread28_2 用时：20毫秒
MyThread28_2 用时：6毫秒
MyThread28 用时：63毫秒
MyThread28 用时：96毫秒
MyThread28 用时：106毫秒
MyThread28 用时：116毫秒
MyThread28 用时：116毫秒

分析：可以发现 MyThread28_2 先执行完，也就验证了线程的优先级与代码的执行顺序无关，出现这样的结果完全是因为 MyThread28_2 的优先级是最高的

1.10.3 优先级具有随机性

线程的优先级具有 “随机性”，也就是优先级较高的线程不一定每一次都先执行完。

下面通过一个示例来演示：

创建两个自定义的线程类

public class MyThread29 extends Thread {
    @Override
    public void run() {
        super.run();
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 100000000; i++) {
            count += i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("MyThread29 用时：" + (endTime - beginTime) + "毫秒");
    }
}

public class MyThread29_2 extends Thread{
    @Override
    public void run() {
        super.run();
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 100000000; i++) {
            count += i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("MyThread29_2 用时：" + (endTime - beginTime) + "毫秒");
    }
}

测试类

public class MyThread29Test {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyThread29 myThread29 = new MyThread29();
            myThread29.setPriority(5);
            myThread29.start();
            MyThread29_2 myThread29_2 = new MyThread29_2();
            myThread29_2.setPriority(6);
            myThread29_2.start();
        }

    }
}

运行结果

MyThread29_2 用时：63毫秒
MyThread29 用时：80毫秒
MyThread29_2 用时：81毫秒
MyThread29 用时：90毫秒
MyThread29 用时：67毫秒
MyThread29_2 用时：70毫秒
MyThread29_2 用时：78毫秒
MyThread29 用时：68毫秒
MyThread29 用时：74毫秒
MyThread29_2 用时：64毫秒

分析：为了让结果体现 “随机性”，所以两个线程的优先级一个设置为 5，另一个设置为 6，让优先级接近一些。从打印结果上来看，MyThread29_2 线程的优先级更高，但 MyThread29_2 线程不一定每一次都先执行完。

1.10.4 看谁运行的快

优先级高的线程和优先级低的谁的运行速度更快，下面通过一个示例来演示：

创建两个自定义的线程类

public class MyThread30 extends Thread {
    private long count = 0;

    public long getCount() {
        return count;
    }

    public void setCount(long count) {
        this.count = count;
    }

    @Override
    public void run() {
        super.run();
        while (true) {
            count++;
        }
    }
}

public class MyThread30_2 extends Thread {
    private long count = 0;

    public long getCount() {
        return count;
    }

    public void setCount(long count) {
        this.count = count;
    }

    @Override
    public void run() {
        super.run();
        while (true) {
            count++;
        }
    }
}

测试类

public class MyThread30Test {
    public static void main(String[] args) {
        try {
            MyThread30 myThread30 = new MyThread30();
            myThread30.setPriority(Thread.NORM_PRIORITY - 3);
            myThread30.start();

            MyThread30_2 myThread30_2 = new MyThread30_2();
            myThread30_2.setPriority(Thread.NORM_PRIORITY + 3);
            myThread30_2.start();

            Thread.sleep(20000);
            myThread30.stop();
            myThread30_2.stop();

            System.out.println("myThread30：" + myThread30.getCount());
            System.out.println("myThread30_2：" + myThread30_2.getCount());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

运行结果

myThread30：5682347365
myThread30_2：7136576679

分析：从打印结果上来看，优先级高的线程运行速度更快

1.11 守护线程

在 Java 线程中有两种线程，一种是用户线程，另一种就是守护（Daemon）线程。

什么是守护线程呢？ 守护线程是一种特殊的线程，它的特性有陪伴的含义，当进程中不存在非守护进程了，则守护线程自动销毁。典型的守护进程就是垃圾回收线程，当进程中没有非守护进程了，则垃圾回收线程也没有存在的必要了，自动销毁。

下面通过一个示例来演示守护线程：

创建一个自定义的线程类

public class MyThread31 extends Thread {
    private int i = 0;

    @Override
    public void run() {
        super.run();
        try {
            while(true){
                i++;
                System.out.println(i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试类

public class MyThread31Test {
    public static void main(String[] args) {
        try {
            MyThread31 myThread31 = new MyThread31();
            // 将一个用户线程设置为守护线程
            myThread31.setDaemon(true);
            myThread31.start();
            Thread.sleep(5000);
            System.out.println("守护线程退出了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

1
2
3
4
5
守护线程退出了

bm1998

发布了64 篇原创文章 · 获赞 20 · 访问量 6477

私信关注

《Java 多线程编程核心技术》笔记——第1章 Java 多线程技能

文章目录

1.1 进程和多线程的概念及线程的优点

1.2 使用多线程

1.2.1 继承 Thread 类

1.2.2 实现 Runnable 接口

1.2.3 实例变量与线程安全

1.2.4 留意 i-- 与 System.out.println() 的异常

1.3 currentThread() 方法

1.4 isAlive() 方法

1.5 sleep() 方法

1.6 getId() 方法

1.7 停止线程

1.7.1 停止不了的线程

1.7.2 判断线程是否是停止状态

1.7.3 能停止的线程——异常法

1.7.4 在沉睡中停止

1.7.5 能停止的线程——暴力停止

1.7.6 方法 stop() 与 java.lang.ThreadDeath 异常

1.7.7 释放锁的不良后果

1.7.8 使用 return 停止线程

1.8 暂停线程

1.8.1 suspend 与 resume 方法的使用

1.8.2 suspend 和 resume 方法的缺点——独占

1.8.3 suspend 和 resume 方法的缺点——不同步

1.9 yield 方法

1.10 线程的优先级

1.10.1 线程优先级的继承性

1.10.2 优先级具有规则性

1.10.3 优先级具有随机性

1.10.4 看谁运行的快

1.11 守护线程

猜你喜欢