场景
本篇博客主要目的是总结,为了在工作中需要用到的时候,随时可以快速找到,毕竟人的记忆力是有限的。下面我们就快速总结一下 Java 实现多线程异步执行耗时代码的四种方式,以便在工作中需要用到的时候,随时可以快速找到。
参考相关链接:
文章目录
- 实现方式一继承 Thread 类
- 实现方式二、实现 Runnable 接口
- 实现方式三、实现 Callable 接口 (有返回值)
- 实现方式四、使用线程池
实现方式一继承 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());
}
}