【面试题精选】创建线程的三种方式

妖狐艹你老母 2022-03-09 12:07 129阅读 0赞

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示：

1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable和Future创建线程

下面让我们分别来看看这三种创建线程的方法。

## 方法一：继承Thread类创建线程 ##

采用此方法创建线程有三个步骤：

1.  创建一个类继承Thread接口
2.  重写run方法
3.  创建线程并执行

代码如下所示：

public class MyThread1 extends Thread{
        @Override
        public void run(){
            // 线程的任务，即线程执行体
            System.out.println("我是继承了Thread创建的线程");
        }
    }
    
     public static void main(String[] args) {
            // 创建线程
            Thread thread = new MyThread1();
            // 启动线程
            thread.start();
        }

执行结果：  
![在这里插入图片描述][2019031308234687.png]

## 方法二、实现Runnable接口创建线程 ##

采用此方法创建线程同样有三个步骤：

1.  创建一个类实现Runnable接口
2.  重写run方法
3.  创建线程并且执行（实现Runnable的类作为Thread的参数进行创建）

代码如下：

public class MyThread2 implements Runnable {
        @Override
        public void run() {
            // 线程的执行体
            System.out.println("我是继承Runnable实现的线程");
        }
    }
    
    public static void main(String[] args) {
            // 创建线程,实现Runnable的实现类作为Thread的参数创建线程
            Thread thread01 = new Thread(new MyThread2());
            // 执行线程
            thread01.start();
        }

![在这里插入图片描述][20190313083230591.png]

## 方法三、使用Callable和Future创建线程 ##

前面两种方法都必须重写run()方法，而此种方法不同，Callable 的实现类要重写call方法作为线程的执行体，而且call方法比run方法更加强大：

*  call() 方法可以带返回值
 *  call() 方法可以声明抛出异常

既然call方法有返回值，也就是线程执行存在返回值，那么我们应该如何接收呢？

Java 5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的目标参数。  
在Future接口里定义了几个公共方法来控制它关联的Callable任务：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean cancel(boolean mayInterruptIfRunning)</td> 
   <td>视图取消该Future里面关联的Callable任务</td> 
  </tr> 
  <tr> 
   <td>V get()</td> 
   <td>返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值</td> 
  </tr> 
  <tr> 
   <td>V get(long timeout,TimeUnit unit)</td> 
   <td>返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException</td> 
  </tr> 
  <tr> 
   <td>boolean isDone()</td> 
   <td>若Callable任务完成，返回True</td> 
  </tr> 
  <tr> 
   <td>boolean isCancelled()</td> 
   <td>如果在Callable任务正常完成前被取消，返回True</td> 
  </tr> 
 </tbody> 
</table>

下面我们来看看使用Callable创建线程的步骤：

1.  创建一个类实现Callable接口
2.  重写call方法，可以根据任务的需要修改返回值类型及异常的声明
3.  创建Callable实现类
4.  创建FutureTask包装Callable的实现类
5.  创建线程，参数为FutureTask对象
6.  可根据需要调用FutureTask对象的get()方法获取call()方法的返回值

代码如下：

public class MyThread03 implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            // 线程的执行体，设置返回值为Integer类型,并声明抛出Exception
            System.out.println("我是继承了Callable接口实现的线程");
            return 5;
        }
    }
    
    public static void main(String[] args) {
            // 创建Callable实现类
            MyThread03 myThread03 = new MyThread03();
            // 创建FutureTask对象包装Callable实现类，同时封装了call方法的返回值
            FutureTask<Integer> futureTask = new FutureTask<>(myThread03);
            // 创建线程，将FutureTask类对象作为Thread的参数
            Thread thread03 = new Thread(futureTask);
            thread03.start();
            // 获取futureTask封装的call方法的返回值,若此时线程任务并未返回参数，此方法会阻塞到任务返回参数为止
            try {
                Integer integer = futureTask.get();
                System.out.println("call方法的返回值为："+integer);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

执行结果：  
![在这里插入图片描述][20190313091603359.png]

[2019031308234687.png]: /images/20220309/33294b70e746479c8f710e84b3ab2d7c.png
[20190313083230591.png]: /images/20220309/b70c1c81dd704579954e13954b3e3268.png
[20190313091603359.png]: /images/20220309/00674a4ef6444c6bbfd6e5ecfb529f87.png