Java 实现多线程【异步】的三种方式
具体什么是多线程和异步执行，这里就不介绍了，能够点开本篇博客的各位看官们，都是想直奔主题看干货，不想浪费时间和精力在一些无关紧要的前奏预热和铺垫上。本篇博客主要目的是总结，为了在工作中需要用到的时候，随时可以快速找到，毕竟人的记忆力是有限的。下面我们就快速总结一下 Java 实现多线程异步执行耗时代码的三种方式，以便在工作中需要用到的时候，随时可以快速找到。
实现方式一、继承 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 接口
相关方法介绍：
| 方法名 | 说明 |
|---|---|
| V call() | 这是 Callable 接口中要实现的方法，相当于 Runnable 接口中的 run 方法 |
| FutureTask(Callable<V> 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);
}
}
三种实现方式的总结
1 继承 Thread 类这种实现方式，实现比较简单，但是扩展性差，因为类只能单继承。
2 实现 Runnable 接口、Callable 接口这两种实现方式，实现比较复杂，但是扩展性比较强。
3 如果想要获取到异步线程中的返回值的话，可以采用实现 Callable 接口这种实现方式。
