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

2023-03-06 11:03:06 线程 带你 一文

一. 继承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任务。

以上就是一文带你搞懂Java中线程的创建方式的详细内容,更多关于Java线程创建方式的资料请关注其它相关文章!

相关文章