初始JavaEE篇——多线程（1）：Thread类的介绍与使用

 找往期文章包括但不限于本期文章中不懂的知识点：

个人主页：我要学编程(ಥ_ಥ)-CSDN博客

所属专栏：JavaEE

目录

创建线程

1、继承 Thread类

2、实现Runnable接口

3、使用匿名内部类

1）继承Thread类的匿名内部类

2）实现Runnable接口

查看线程的状态

Thread类的常见属性与方法

---

创建线程

Thread 是线程的意思，在Java中也是通过 Thread类中的 start 方法启动一个线程。但要注意的是，每一个线程对象都只能调用一次 start方法，如果后续再去调用的话，便会抛异常。

在Java中有四种方式实现多线程。

1、继承 Thread类

语法格式：

// 继承Thread类
class MyThread extends Thread {@Overridepublic void run() {....... // 代码}
}public class Test {public static void main(String[] args) {Thread t = new MyThread();// 启动 t线程，调用run方法t.start();// 后续代码.......}
}

 我们创建一个新的类，使其继承Thread类，并重写其中的run方法。这就已经具备了一个线程的基本雏形，现在只要我们在main线程中去实例化这个类，并且启动这个线程即可。启动线程的方法是通过调用线程对象的start方法，start方法会启动一个新的线程并在这个新线程中自动调用run方法，完成该线程的所执行的任务。

// 1、继承Thread类
class MyThread extends Thread {@Overridepublic void run() { // 重写run方法while (true) {System.out.println("Hello Thread");}}
}public class Test {public static void main(String[] args) {Thread t = new MyThread();// 启动 t线程，调用run方法t.start(); // 这里发生了多态while (true) {System.out.println("Hello main");}}
}

上述代码运行后，会出现 Hello main 和 Hello Thread  循环交替的打印，这便是多线程。main线程在运行的同时，t 线程也在运行。

从结果上也能看出这是在并发执行，main线程在CPU上运行一段时间，t 线程接着在CPU上运行一段时间。 我们可以使用 sleep 方法来放慢观察。与C语言中的sleep函数一样，是让程序休眠的方法。下面就来详细介绍一下：

Java中的sleep方法是Thread类的一个静态方法，参数是要休眠时间，单位是毫秒。我们可以先写一个代码来演示：

public class Test {public static void main(String[] args) throws InterruptedException {while (true) {System.out.println("Hello main");Thread.sleep(1000); // 会抛异常，需要throws或者try-catch}}
}

上面的代码会打印一个 Hello main 之后，休眠1000毫秒，即1秒。 

 注意：这个休眠是让线程主动的放弃CPU资源。

现在我们可以近距离观察多线程的运行情况了。

// 1、继承Thread类
class MyThread extends Thread {@Overridepublic void run() {while (true) {System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new MyThread();// 启动 t线程，调用run方法t.start(); // 这里发生了多态while (true) {System.out.println("Hello main");Thread.sleep(1000);}}
}

运行结果： 

有细心的小伙伴应该发现了，使用sleep方法时， run方法和main方法中的处理方式不一样，run方法是通过try-catch的形式，而main方法中两种都是可以的。这是因为run方法是重写了Thread类中的run方法，父类的没有throws这个操作，因此子类在重写时也不能有throws操作，不然就会改变run方法的框架，从而不符合重写的概念。 

2、实现Runnable接口

// 实现Runnable接口
class MyRunnable implements Runnable {@Overridepublic void run() {....... // 代码}
}public class Test {public static void main(String[] args) {Thread t = new Thread(new MyRunnable());// 启动 t线程，并调用run方法t.start();// 后续代码}
}

我们创建一个新的类，实现 Runnable接口，重写 run方法。接着在main方法中将实例化一个Thread类对象，将 实现Runnable接口的类实例化作为参数传入Thread中。

代码演示：

class MyRunnable implements Runnable {@Overridepublic void run() {while (true) {System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(new MyRunnable());// 启动 t线程，调用run方法t.start();while (true) {System.out.println("Hello main");Thread.sleep(1000);}}
}

运行结果：

注意：我们使用t.run方法也能执行代码，但是得不到 t.start的效果。因为t.run方法不会创建线程，只是一个简单的方法调用，那么最终代码就会一直死循环打印 Hello Thread。如下所示：

使用 t.start 时，是先创建的线程，然后再去调用的run方法，因此 t 线程和main线程会并发执行。 

上面是两种主要的创建线程的方式，剩下的两种就是通过对上面的变形来编写的。

3、使用匿名内部类

使用匿名内部类有两种选择，一个是继承Thread类，一个是实现Runnable接口

1）继承Thread类的匿名内部类

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(){@Overridepublic void run() {while (true) {System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}};// 启动 t线程，调用run方法t.start();while (true) {System.out.println("Hello main");Thread.sleep(1000);}}
}

 当然除了上面这种写法，还有另一种写法：

public class Test {public static void main(String[] args) throws InterruptedException {new Thread(){@Overridepublic void run() {while (true) {System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}}.start(); // 这里启动了线程，并调用了run方法while (true) {System.out.println("Hello main");Thread.sleep(1000);}}
}

第一种写法是通过父类引用来接收子类对象，而第二种写法就是一次性的线程，当这次使用完成之后，后续再也不能使用该线程了。

2）实现Runnable接口

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(// 创建一个匿名对象，该对象是实现了Runnable接口的匿名内部类new Runnable() {@Overridepublic void run() {while (true) {System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});// 启动 t线程，并调用run方法t.start();while (true) {System.out.println("Hello main");Thread.sleep(1000);}}
}

 由于 Runnable 接口是函数式接口（一个接口中只包含一个抽象方法），因此我们可以使用lambda表达式来简写。

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(()->{while (true) {System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});// 启动 t线程，并调用run方法t.start();while (true) {System.out.println("Hello main");Thread.sleep(1000);}}
}

lambda表达式："()" 这个要重写的方法的参数 ，"->" 是必不可少的，"{}" 这里面是要重写的方法的方法体，即具体的代码。

以上就是创建线程的全部方法了。

我们在日常的开发中，使用最多的就是通过实现 Runnable 接口来创建线程。因为我们在使用 Runnable 接口创建线程时，是将实现该接口的对象作为参数传入，这样后续如果要修改代码的话，也只需要在实现该接口的内部进行修改，而不需要再去改动main线程中的代码了。这样代码之间的依赖程度就降低了，而是通过模块来之间来依赖维护，也就达到了高内聚、低耦合的效果。而使用 lambda 表达式来简写代码的方式则是既方便，可读性也不差。因此我们基本上是使用 lambda 表达式来简写实现 Runnable 接口来创建线程。

查看线程的状态

我们可以通过JDK自带的工具来查看当前进程的状态以及具体线程的相关状态。

1、找到安装JDK的目录。

2、找到bin目录下的 jconsole 这个.exe文件，并双击运行。

3、找到要连接的进程，一般对应的类名，然后点击连接即可。下图是双击运行后的界面：

以上就是关于如果查看线程相相关信息的操作。

Thread类的常见属性与方法

上面我们是采用了Thread类的两种构造方法来创建线程的，其实除了上面的方法外还有其他的几种构造方法。

方法	描述
Thread()	创建线程对象
Thread(Runnable target)	使用Runnable对象创建线程对象
Thread(String name)	创建线程对象，并命名
Thread(Runnable target, String name)	使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group, Runnable target)	这个暂时不需要用到，后期再学习

注意：使用 Thread() 和 Thrad(String name)，这两个方法都是要重写 run 方法的，而另外两个虽然使用 Runnable，但本质上还是要重写 run 方法。因此对于一个线程最重要的就是 run方法，虽然 start 方法是启动线程，但是只要 run 方法执行完毕，通常这个线程就会被销毁。  

下面就来学习线程的常见属性：

属性	获取方法
ID	getld()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程（守护线程）	isDaemon()
是否存活	isAlive()
是否被中断	islnterrupted()

解释：

1、ID 是线程的唯一标识、名称是各种调试工具用到、状态表示线程当前所处的一个情况：就绪态、阻塞态、运行态等。

2、优先级是指当多个线程同时被调度时，由于是随机调度的，不能确保某个线程一定会被第一时间执行，但如果某个线程的优先级比较高的话，那么就会先运行该线程。

3、后台线程也叫作守护线程，即这个线程只是默默守护， 并不会干扰到程序的正常运行，当程序正常运行结束后（进程结束了），后台线程也就被销毁了，但是前台线程不一样，只有当全部的前台线程运行结束后，进程才会结束。简单理解就是，后台线程不能干预进程的结束，而前台线程可以干预进程的结束。

从上面，我们查看线程的状态那里可以看出来，我们自己创建的线程默认都是前台线程。我们也可以通过代码来观察：

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(()->{while (true) {System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});// 设置成后台线程t.setDaemon(true);// 启动 t线程，并调用run方法t.start();for (int i = 0; i < 3; i++) {System.out.println("Hello main");Thread.sleep(1000);}System.out.println("main线程结束！进程也就结束了");}
}

运行结果：

注意：设置线程的属性一定要在调用start方法之前，因为一旦调用start方法之后，线程启动了，那么就是按照其默认的属性来进行运行了，则最终不会停下来。

4、线程是否存活，简单理解就是看run方法是否执行完毕，但有些特殊情况下，即使run方法执行完毕，线程依旧存活。

我们也是可以通过代码来观察的。

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(()->{System.out.println("Hello Thread");System.out.println("t线程结束");});// 看看线程启动前是否存活System.out.println(t.isAlive());t.setDaemon(true);// 启动 t线程，并调用run方法t.start();// 看看结束前是否存活System.out.println(t.isAlive());// 确保 t线程已经结束了Thread.sleep(1000);// 看看结束后是否存活System.out.println(t.isAlive());System.out.println("main线程结束，进程结束！");}
}

运行结果：

从运行的结果，我们可以看出启动前、结束后线程都已经灭亡了，当线程还在执行run方法时，线程就是存活的。 

5、线程的中断就是让线程结束，而让线程结束就只有一个办法：让 run方法提前结束，而让run方法提前就是让while循环提前结束，即在while循环的条件语句中来判断。

我们可以用代码来演示：

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(()->{while (!Thread.currentThread().isInterrupted()) { // 判断是否是中断System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("t线程结束");});// 启动 t线程，并调用run方法t.start();Thread.sleep(3000);// 中断t.interrupt();System.out.println("main线程结束");}
}

运行结果：

首先，来解读代码：

1、因为 t 在lambda表达式之后才才会创建，因此我们在调用 isInterrupted 方法时，不能通过 t 来调用，要通过 Thread.currentThread 方法来获取当前的类对应的对象，然后再用这个对象去调用 isInterrupted 方法。

2、Thread.currentThread().isInterrupted() 方法会返回 false ，因为线程在执行的过程中是处于非中断的状态，因此我们要对其进行 取反操作，才能使其进入while循环。

3、 当我们编写 t.interrupt() 的代码时，线程确实会中断，但是由于 打印语句的执行是非常快的，因此在 t 线程的生命周期中，绝大部分时间是处于休眠状态，而此方法会唤醒sleep，使其抛出异常，因此只要我们在 throw 异常的代码中，使用break 或者 啥也不做，那么就不会抛出异常。

上述是使用 break的效果，但如果我们 啥也不干的话，发现不会停下来。

其实是 sleep 在捣乱。正常来说，调用 Interrupt 方法将 isInterrupted 方法内部的标志位设置为了 true ，但由于上述代码中把 sleep 给唤醒了，这种提前唤醒的情况下，sleep 就会在唤醒之后，把 islnterrupted 标志位给设置回 false。所以后续在进行判断的时候，还是会进入while循环。

好啦！本期 初始JavaEE篇——多线程（1）：Thread类的介绍与使用 的学习之旅到此结束啦！我们下一期再一起学习吧！