一文搞懂Java线程的创建方式

上一篇 / 下一篇  2023-04-25 15:35:51

查看( 220 ) / 评论( 0 ) / 评分( 0 / 0 )
　　前言
　　本篇文章将对Java中的线程创建进行实战说明。
　　正文
　　一. 继承Thread
　　可以通过创建Thread的子类并在子类中重写run() 方法完成线程创建。示例如下所示。
　　public class ThreadTest {
　　    @Test
　　    public void 继承Thread() throws Exception {
　　        // 创建线程对象
　　        MyThread myThread = new MyThread();
　　        // 启动线程
　　        myThread.start();
　　        // 睡1秒，等待子线程执行完任务
　　        Thread.sleep(1000);
　　    }
　　    private static class MyThread extends Thread {
　　        @Override
　　        public void run() {
　　            System.out.println("线程执行了");
　　        }
　　    }
　　}
　　运行测试程序，打印如下。
　　其实可以只继承Thread，而不重写run() 方法，此时是不会报错的，只不过调用start() 方法后线程不会执行任何逻辑。示例如下。
　　public class ThreadTest {
　　    @Test
　　    public void 继承Thread时可以不重写run方法() {
　　        // 创建没有重写run()方法的线程对象
　　        MyThreadNotOverrideRun myThread = new MyThreadNotOverrideRun();
　　        // 启动线程，不报错，执行的是Thread的run()方法，无任何逻辑
　　        myThread.start();
　　    }
　　    private static class MyThreadNotOverrideRun extends Thread {}
　　}
　　二. 创建Runnable对象
　　可以通过创建Runnable接口的实现类，然后将Runnable对象作为Thread对象的执行任务，来创建线程。示例如下。
　　public class ThreadTest {
　　    @Test
　　    public void 基于Runnable() throws Exception {
　　        // 创建Runnable任务对象
　　        Runnable runnable = new Runnable() {
　　            @Override
　　            public void run() {
　　                System.out.println("任务执行");
　　            }
　　        };
　　        // 创建Thread对象时将Runnable任务对象通过构造函数传入
　　        Thread thread = new Thread(runnable);
　　        // 启动线程
　　        thread.start();
　　        // 睡1秒，等待子线程执行完任务
　　        Thread.sleep(1000);
　　    }
　　}
　　运行测试程序，执行结果如下所示。
　　三. 创建Callable对象
　　Callable接口也是可以作为任务被线程执行，其与Runnable接口的区别在于Callable任务可以有返回值，而Runnable任务没有返回值。
　　由于Thread对象只能执行Runnable任务，因此无法直接让Thread执行Callable任务，但是可以先将Callable封装成FutureTask，而FutureTask是实现了Runnable接口的，所以Thread对象可以执行FutureTask任务。示例如下。
　　public class ThreadTest {
　　    @Test
　　    public void 基于Callable() throws Exception {
　　        // 创建Callable任务对象
　　        Callable<String> callable = new Callable<String>() {
　　            @Override
　　            public String call() throws Exception {
　　                return "任务执行结果";
　　            }
　　        };
　　        // 将Callable封装成FutureTask
　　        FutureTask<String> futureTask = new FutureTask<>(callable);
　　        // 创建Thread对象时将FutureTask通过构造函数传入
　　        Thread thread = new Thread(futureTask);
　　        // 启动线程
　　        thread.start();
　　        // 通过FutureTask拿到执行结果
　　        System.out.println(futureTask.get());
　　    }
　　}
　　运行测试程序，结果如下。
　　四. 基于Runnable创建FutureTask
　　在第三小节中是基于Callable来创建的FutureTask，本小节将基于Runnable来创建FutureTask。在此之前，先看一下FutureTask的类图，如下所示。
　　所以FutureTask即能够作为Runnable被执行，也能够作为Future获取异步执行的结果。FutureTask有两个构造函数，签名如下。
　　// 基于Callable创建FutureTask
　　public FutureTask(Callable<V> callable)
　　// 基于Runnable创建FutureTask
　　public FutureTask(Runnable runnable, V result)
　　下面重点看一下如何基于Runnable创建FutureTask，源码如下所示。
　　public FutureTask(Runnable runnable, V result) {
　　    // 使用Executors工具类将Runnable封装成Callable
　　    this.callable = Executors.callable(runnable, result);
　　    this.state = NEW;
　　}
　　继续看Executors#callable(java.lang.Runnable, T) 方法，如下所示。
　　public static <T> Callable<T> callable(Runnable task, T result) {
　　    if (task == null) {
　　        throw new NullPointerException();
　　    }
　　    // 将Runnable封装成RunnableAdapter
　　    return new RunnableAdapter<T>(task, result);
　　}
　　那么Executors#callable(java.lang.Runnable, T) 方法中就是将Runnable封装成了RunnableAdapter，最后再看一下RunnableAdapter的实现。
　　static final class RunnableAdapter<T> implements Callable<T> {
　　    final Runnable task;
　　    final T result;
　　    
　　    RunnableAdapter(Runnable task, T result) {
　　        this.task = task;
　　        this.result = result;
　　    }
　　    
　　    public T call() {
　　        // 执行Runnable的逻辑
　　        task.run();
　　        // 执行完毕后，result作为结果返回
　　        return result;
　　    }
　　}
　　所以这里可以知道，基于Runnable创建FutureTask，其本质是将Runnable先封装为Callable，然后再将Callable封装成FutureTask。还有一点需要注意，在基于Runnable创建FutureTask时，除了传入Runnable，还可以传入一个作为返回结果的对象，Runnable执行完毕后，会将这个对象返回，这个对象也可以传一个null，表示不需要返回值。
　　基于Runnable创建FutureTask的一个示例如下。
　　public class ThreadTest {
　　    @Test
　　    public void 基于Runnable来构建FutureTask() throws Exception {
　　        // 创建结果对象
　　        MyResult myResult = new MyResult();
　　        // 创建Runnable任务对象
　　        Runnable runnable = new Runnable() {
　　            @Override
　　            public void run() {
　　                myResult.setResult("任务执行");
　　            }
　　        };
　　        // 将Runnable封装成FutureTask
　　        // Runnable执行后，会改变MyResult对象
　　        FutureTask<MyResult> futureTask = new FutureTask<>(runnable, myResult);
　　        // 创建Thread对象时将FutureTask通过构造函数传入
　　        Thread thread = new Thread(futureTask);
　　        // 启动线程
　　        thread.start();
　　        // 通过FutureTask拿到执行结果
　　        System.out.println(futureTask.get().getResult());
　　    }
　　    private static class MyResult {
　　        String result;
　　        public MyResult() {}
　　        public MyResult(String result) {
　　            this.result = result;
　　        }
　　        public String getResult() {
　　            return result;
　　        }
　　        public void setResult(String result) {
　　            this.result = result;
　　        }
　　    }
　　}
　　运行测试程序，结果如下所示。
　　总结
　　线程的创建，总的概括有三种方式。
　　继承Thread并重写run()方法；
　　创建Thread并执行Runnable任务；
　　创建Thread并执行Callable任务。

收藏 举报

TAG: 软件开发 Java java

 

评分：0

我来说两句

Open Toolbar