java 异步执行代码传参数 java实现异步执行

转载

mob6454cc659b12 2024-07-10 21:12:59

文章标签 java 异步执行代码传参数 System 构造方法异步线程 文章分类 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);
    }
}