乐趣区

关于java:有哪些创建线程的方法推荐使用哪种

在 Java 中,线程的创立办法有 7 种,分为以下 3 大类:

  1. 继承 Thread 类的形式,它有 2 种实现办法。
  2. 实现 Runnable 接口的形式,它有 3 种实现办法。
  3. 实现 Callable 接口的形式,它有 2 种实现办法。

接下来咱们一个一个来看。

1. 继承 Thread 类

继承 Thread 类并重写 run 办法,是最晚期创立线程的办法,它的实现办法有以下两种:

  1. 创立一个一般的类,继承 Thread 类,并重写 run 办法。
  2. 应用匿名外部类的形式继承并重写 run 办法。

具体实现如下。

1.1 一般类继承 Thread

创立一个一般类,继承 Thread 并重写 run 办法,其中 run 办法中的代码是线程具体要执行的业务代码,实现如下:

// 自定义一个类继承 Thread 并重写 run 办法
class MyThread extends Thread {
    @Override
    public void run() {// 增加业务办法...}
}
// 创立线程并执行
public class ThreadExample {public static void main(String[] args) {
        // 创立线程
        Thread thread = new MyThread();
        // 启动线程
        thread.start();}
}

1.2 匿名外部类

下面的写法有点繁琐,咱们还能够应用以下匿名类的形式来实现:

// 匿名形式创立线程
Thread t1 = new Thread() {
    @Override
    public void run() {// 增加业务办法...}
};
// 启动线程
t1.start();

1.3 毛病剖析

继承 Thread 类的实现办法有一个显著的毛病,Java 语言是单继承的,所以如果继承了 Thread 类,那就不能再继承其余类了。

2. 实现 Runnable 接口

在 Java 语言中,尽管不能多继承,但能够实现多个接口。接下来是实现 Runnable 接口的 3 种办法:

  1. 创立一个一般类实现 Runnable 接口,并重写 run 办法。
  2. 应用匿名形式创立 Runnable 实现类,并重写 run 办法。
  3. 应用 Lambda 形式创立匿名 Runnable 实现类(JDK 8+)。

    2.1 一般类实现 Runnable

    // 定义一个一般类实现 Runnable 接口
    class MyRunnable implements Runnable {
     @Override
     public void run() {// 增加业务办法...}
    }
    // 线程创立
    public static void main(String[] args) {
     // 创立一个 Runnable 实现类
     MyRunnable myRunnable = new MyRunnable();
     // 创立线程
     Thread thread = new Thread(myRunnable);
     // 启动线程
     thread.start();}

    2.2 匿名 Runnable 实现类

    // 匿名 Runnable 实现类
    Thread t2 = new Thread(new Runnable() {
     @Override
     public void run() {// 增加业务办法...}
    });
    // 启动线程
    t2.start();

    2.3 Lambda 创立 Runnable

    在 JDK 8 之后(蕴含 JDK 8),咱们能够应用 Lambda 表达式来创立线程,如下代码所示:

    // 应用 Lambda 匿名 Runnable 形式
    Thread t3 = new Thread(() -> {// 增加业务办法...});
    // 启动线程
    t3.start();

    从上述代码能够看出, 如果是 JDK 1.8 以上的程序,在不要求取得线程执行后果的状况下,举荐应用 Lambda 的形式来创立线程,因为它的写法足够简洁

    2.4 毛病剖析

    以上创立线程的办法,都有一个通用的问题:那就是不能取得线程的执行后果。

    3. 应用 Callable 接口

    JDK 1.5 中推出的 Callable 接口,解决了之前不能取得线程执行后果的难堪 ,它的实现办法有以下两种:

  4. 创立一个一般类实现 Callable 接口,并重写 call 办法。
  5. 应用匿名外部类创立 Callable 的实现类,并重写 call 办法。

    3.1 一般类实现 Callable

    // 定义一般实现 Callable 接口,返回一个 Integer 类型的后果(当然也能够返回其余类型的后果)class MyCallable implements Callable<Integer> {
     @Override
     public Integer call() throws Exception {
         // 业务实现代码...
         return 0;
     }
    }
    // 创立线程
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     // 创立 Callable 一般类
     MyCallable callable = new MyCallable();
     // 应用 FutureTask 用于获取线程执行后果
     FutureTask<Integer> futureTask = new FutureTask<>(callable);
     // 创立线程
     Thread thread = new Thread(futureTask);
     // 启动线程
     thread.start();
     // 失去线程执行的后果
     int result = futureTask.get();}
    

    以上代码应用 FutureTask + Callable 的形式获取线程的执行后果,它能够承受任何类型的返回值,咱们只须要在创立 Callable 实现类的时候,定义返回的数据类型即可。

    3.2 匿名 Callable 实现类

    // FutureTask 用于获取线程执行后果
    FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
     @Override
     public Integer call() throws Exception {
         // 业务代码...
         return 0;
     }
    });
    // 创立线程
    Thread thread = new Thread(futureTask);
    // 启动线程
    thread.start();
    // 失去线程执行的后果
    int result = futureTask.get();

    总结

    在 Java 语言中,创立线程有 3 大类实现形式、7 种实现办法,如果是 JDK 1.8 以上版本,在不须要取得线程执行后果的状况下,举荐应用 Lambda 形式来创立线程,因为它的写法足够简洁;如果想要获取线程执行后果,可应用 FutureTask + Callable 的形式来实现。

是非审之于己,毁誉听之于人,得失安之于数。

公众号:Java 面试真题解析

面试合集:https://gitee.com/mydb/interview

退出移动版