Java多线程的五种实现方式

最新推荐文章于 2024-09-23 22:36:07 发布

2401_84831762

最新推荐文章于 2024-09-23 22:36:07 发布

阅读量944

点赞数 23

分类专栏：程序员文章标签： java python 开发语言

本文链接：https://blog.csdn.net/2401_84831762/article/details/138888211

版权

程序员专栏收录该内容

109 篇文章 0 订阅

订阅专栏

1、创建多个线程

上面的例子中除了我们创建的一个线程以外其实还有一个主线程也在执行。那么除了这两个线程以外还有没有其他的线程在执行了呢，其实是有的，比如我们看不到的垃圾回收线程，也在默默的执行。这里我们并不去考虑有多少个线程在执行，上面我们自己创建了一个线程，那么能不能多创建几个一起执行呢，答案是肯定的。一个Thread类就是一个线程对象，那么多创建几个Thread类，并调用其start方法就可以启动多个线程了。

代码如下：

package com.thread.create;

/**

@author riemann
@date 2019/07/13 15:48

public class CreateThreadDemo2 extends Thread {

public CreateThreadDemo2(String name) {

// 设置当前线程的名字

this.setName(name);

}

public void run() {

// 每隔1s中输出一次当前线程的名字

while (true) {

// 输出线程的名字，与主线程名称相区分

printThreadInfo();

commonThreadSleep();

}

public static void main(String[] args) {

// 注意这里，要调用start方法才能启动线程，不能调用run方法

new CreateThreadDemo2(“MyThread-01”).start();

new CreateThreadDemo2(“MyThread-02”).start();

// 演示主线程继续向下执行

while (true) {

printThreadInfo();

commonThreadSleep();

}

private static void commonThreadSleep() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

private static void printThreadInfo() {

System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());

}

运行结果如下：

当前运行的线程名为： main

当前运行的线程名为： MyThread-01

当前运行的线程名为： MyThread-02

当前运行的线程名为： MyThread-01

当前运行的线程名为： main

当前运行的线程名为： MyThread-02

当前运行的线程名为： MyThread-01

当前运行的线程名为： main

当前运行的线程名为： MyThread-01

当前运行的线程名为： MyThread-02

当前运行的线程名为： main

2、指定线程名称

可以看到，通过创建多个Thread类，并且调用其start方法，启动了多个线程。每个线程都有自己的名字，在上述代码中，分别给创建的线程指定了MyThread-01和MyThread-02这个名字，然后构造方法中通过调用父类的setName方法给线程名字赋值。如果不指定线程名字，系统会默认指定线程名，命名规则是Thread-N的形式。但是为了排查问题方便，建议在创建线程的时候指定一个合理的线程名字。下面的代码是不使用线程名的样子。

package com.thread.create;

/**

@author riemann
@date 2019/07/13 15:48

public class CreateThreadDemo3 extends Thread {

public void run() {

// 每隔1s中输出一次当前线程的名字

while (true) {

// 输出线程的名字，与主线程名称相区分

printThreadInfo();

commonThreadSleep();

}

public static void main(String[] args) {

// 注意这里，要调用start方法才能启动线程，不能调用run方法

new CreateThreadDemo3().start();

// 演示主线程继续向下执行

while (true) {

printThreadInfo();

commonThreadSleep();

}

private static void commonThreadSleep() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

private static void printThreadInfo() {

System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());

}

运行的结果如下：

当前运行的线程名为： main

当前运行的线程名为： Thread-1

当前运行的线程名为： Thread-0

当前运行的线程名为： Thread-1

当前运行的线程名为： Thread-0

当前运行的线程名为： main

二、第二种方式：实现Runnable接口

实现Runnable接口也是一种常见的创建线程的方式，使用接口的方式可以让我们的程序降低耦合度。Runnable接口中仅仅定义了一个方法，就是run。我们来看一下Runnable接口的代码。

package java.lang;

@FunctionalInterface

public interface Runnable {

public abstract void run();

}

其实Runnable就是一个线程任务，线程任务和线程的控制分离，这也就是上面所说的解耦。我们要实现一个线程，可以借助Thread类，Thread类要执行的任务就可以由实现了Runnable接口的类来处理。这就是Runnable的精髓之所在！

Runnable 是一个@FunctionalInterface 函数式接口，也就意味了可以利用JDK8提供的lambda的方式来创建线程任务，后面的代码中会给读者演示具体如何使用。

使用Runnable实现上面的例子步骤如下：

定义一个类实现Runnable接口，作为线程任务类
重写run方法，并实现方法体，方法体的代码就是线程所执行的代码
定义一个可以运行的类，并在main方法中创建线程任务类
创建Thread类，并将线程任务类作为Thread类的构造方法传入
启动线程

1、创建线程任务

线程任务就是线程要做的事情，这里我们让这个线程每隔1s中打印自己的名字

package com.thread.create;

/**

@author riemann
@date 2019/07/13 16:07

public class CreateThreadDemo3_Task implements Runnable {

@Override

public void run() {

// 每隔1s中输出一次当前线程的名字

while (true) {

printThreadInfo();

commonThreadSleep();

}

public static void commonThreadSleep() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

private static void printThreadInfo() {

System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());

}

2、创建可运行类

在这里创建线程，并把任务交给线程处理，然后启动线程。

package com.thread.create;

/**

@author riemann
@date 2019/07/13 16:10

public class CreateThreadDemo3_Main {

public static void main(String[] args) {

// 实例化线程任务类

CreateThreadDemo3_Task task = new CreateThreadDemo3_Task();

// 创建线程对象,并将线程任务类作为构造方法参数传入

new Thread(task).start();

// 主线程的任务，为了演示多个线程一起执行

while (true) {

printThreadInfo();

commonThreadSleep();

}

public static void commonThreadSleep() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

private static void printThreadInfo() {

System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());

}

线程任务和线程的控制分离，那么一个线程任务可以提交给多个线程来执行。这是很有用的，比如车站的售票窗口，每个窗口可以看做是一个线程，他们每个窗口做的事情都是一样的，也就是售票。这样我们程序在模拟现实的时候就可以定义一个售票任务，让多个窗口同时执行这一个任务。那么如果要改动任务执行计划，只要修改线程任务类，所有的线程就都会按照修改后的来执行。相比较继承Thread类的方式来创建线程的方式，实现Runnable接口是更为常用的。

3、lambda方式创建线程任务

这里就是为了简化内部类的编写，简化了大量的模板代码，显得更加简洁。如果读者看不明白，可以先看下这篇关于Lambda表达式的博文：Java8函数式接口与Lambda表达式

package com.thread.create;

/**

@author riemann
@date 2019/07/13 16:17

public class CreateThreadDemo3_Lambda {

public static void main(String[] args) {

// 使用lambda的形式实例化线程任务类

Runnable task = () -> {

while (true) {

// 输出线程的名字

printThreadInfo();

}

};

// 创建线程对象,并将线程任务类作为构造方法参数传入

new Thread(task).start();

// 主线程的任务，为了演示多个线程一起执行

while (true) {

printThreadInfo();

commonThreadSleep();

}

public static void commonThreadSleep() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

private static void printThreadInfo() {

System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());

commonThreadSleep();

}

4、内部类方式

我们来使用匿名内部类，会发现代码还是比较冗余的，lambda可以大大简化代码的编写。用lambda来改写上面的基于接口的形式的代码，如下

// 使用lambda的形式

new Thread(() -> {

while (true) {

printThreadInfo();

}

}).start();

// 对比不使用lambda的形式

new Thread(new Runnable() {

@Override

public void run() {

while (true) {

printThreadInfo();

}

}).start();

自己对比一下也不难发现 lambda 比匿名内部类的写法更简洁。

三、第三种方式：带返回值的线程实现方式

我们发现上面提到的不管是继承Thread类还是实现Runnable接口，发现有两个问题，第一个是无法抛出更多的异常，第二个是线程执行完毕之后并无法获得线程的返回值。那么下面的这种实现方式就可以完成我们的需求。这种方式的实现就是我们后面要详细介绍的Future模式，只是在jdk5的时候，官方给我们提供了可用的API，我们可以直接使用。但是使用这种方式创建线程比上面两种方式要复杂一些，步骤如下。