场景
本篇博客主要目的是总结，为了在工作中需要用到的时候，随时可以快速找到，毕竟人的记忆力是有限的。下面我们就快速总结一下 Java 实现多线程异步执行耗时代码的四种方式，以便在工作中需要用到的时候，随时可以快速找到。
参考相关链接:
https://www.cnblogs.com/studyjobs/p/15763937.html
https://blog.csdn.net/qq_42764468/article/details/122988589
实现方式一继承 Thread 类
继续 Thread 的子类，需要用到的方法介绍：
| 方法名 | 说明 |
|---|---|
| void run() | 在线程开启后，此方法将被调用执行，不能直接调用该方法实现多线程 |
| void start() | 使此方法开启一个新线程并开始执行，Java虚拟机会自动调用 run方法 |
实现步骤：
- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run()方法
- 创建MyThread类的对象
- 启动线程
代码实现：
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0; i<50; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
//这里直接调用 run 方法，并不会开启新线程执行
//my1.run();
//my2.run();
//必须调用 start 方法，才能开启新线程并自动调用 run 方法
my1.start();
my2.start();
}
}
实现方式二、实现 Runnable 接口
需要用到的 Thread 构造方法介绍：
| 方法名 | 说明 |
|---|---|
| Thread(Runnable target) | 传入实现了 Runnable 接口的类，构造一个 Thread 对象 |
| Thread(Runnable target, String name) | 传入实现了 Runnable 接口的类，构造一个名称为 name 的 Thread 对象 |
实现步骤：
- 定义一个类 MyRunnable 实现 Runnable 接口
- 在 MyRunnable 类中实现 run() 方法
- 创建 MyRunnable 类的对象
- 创建 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数
- 启动线程
代码实现：
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0; i<50; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class MyRunnableDemo {
public static void main(String[] args) {
MyRunnable my = new MyRunnable();
//Thread t1 = new Thread(my);
//Thread t2 = new Thread(my);
Thread t1 = new Thread(my,"线程一");
Thread t2 = new Thread(my,"线程二");
//启动线程
t1.start();
t2.start();
}
}
实现方式三、实现 Callable 接口 （有返回值）
需要用到的 Thread 构造方法介绍：
| 方法名 | 说明 |
|---|---|
| V call() | 这是 Callable 接口中要实现的方法，相当于 Runnable 接口中的 run 方法 |
| FutureTask(Callable callable) | 使用 Callable 接口实现类实例创建一个 FutureTask，它运行时会调配用 Callable 接口中的 call 方法 |
| V get() | FutureTask 实例的 get 方法，可以阻塞代码继续往下执行，直到获取到异步线程中的返回结果为止 |
实现步骤：
- 定义一个类 MyCallable 实现 Callable 接口
- 在 MyCallable 类中重实现 call() 方法
- 创建 MyCallable 类的对象
- 创建 FutureTask 对象，把 MyCallable 对象作为构造方法的参数
- 创建 Thread 类的对象，把 FutureTask 对象作为构造方法的参数
- 启动线程
- 如果想获取返回值的话，可以调用get方法，就可以获取线程结束之后的结果
代码实现：
//因为这里想返回 String 值，所以实现 String 类型的 Callable 接口
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
//这里返回一个字符串
return "这是我返回的字符串结果";
}
}
public class CallableDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable mc = new MyCallable();
//因为 MyCallable 实现了 String 类型的 Callable 接口
//所以返回值也是 String 类型，所以创建的是 String 类型的 FutureTask 对象
FutureTask<String> ft = new FutureTask<>(mc);
//传入 FutureTask 实例，创建线程对象
Thread t1 = new Thread(ft);
//不能在这个地方使用 FutureTask 的 get 方法获取异步线程的返回值，否则程序将卡死在这里。
//因为 t1 线程还没有执行，所以无法获取到返回值，所以如果执行 get 方法，程序将卡死在这里。
//String s = ft.get();
//开启新线程，异步执行 MyCallable 实例中的 call 方法逻辑
t1.start();
//这里编写一些实现其它业务逻辑代码进行执行
//可以做一些其它比较耗时的任务
//......
//获取异步线程的返回值
String s = ft.get();
System.out.println(s);
}
}
实现方式四、使用线程池
以下使用不同的线程类型时要注意
- Runnbale类型 ：为 threadpool.execute
- Callable类型：为threadpool.submit
future.get() ：该方法时Callable类型独有的；会得到该线程执行完毕后的返回值
使用 future.get() 时会阻塞 Callable类型 的线程，虽然不会阻塞影响Runnbale 类型的线程，但是多多少少会影响整个线程池实现方法的阻塞。
相关代码
public class RunnableTaskDemo implements Runnable {
@Override
public void run() {
for(int i=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+" 轮次："+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class CreateDemo {
//创建有3个线程的线程池
private static ExecutorService threadpool = Executors.newFixedThreadPool(3);
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 1、执行Runnbale类型的target目标实例，无返回
threadpool.execute(new RunnableTaskDemo());
//2、 执行Runnbale类型的target目标实例，无返回，（内部类形式写法）
threadpool.execute(new Runnable() {
@Override
public void run() {
for(int i=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+" 轮次："+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
// 3、提交Callable执行目标实例，有返回
Future future = threadpool.submit(new CallableTaskDemo());
System.out.println("异步执行的结果为：" + future.get());
}
}