线程的四种创建方式

痛定思痛。 2022-02-28 11:44 272阅读 0赞

### Java多线程实现方式主要有四种： ###

1.  继承Thread类；
2.  实现Runnable接口；
3.  实现Callable接口通过FutureTask包装器来创建Thread线程；
4.  使用ExecutorService、Callable、Future实现有返回结果的多线程。

**其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。**

在详细了解这四种方法之前，先来理解一下为什么线程要这样创建：形象点来说，Thread是一个工人，run（）方法里面的便是他的任务栏，这个任务栏默认是空的。当你想要这个线程做点什么时，你可以重写Thread里面的run方法，重写这个工人的任务栏；也可以通过runable、callable接口，从外部赋予这个工人任务。还可以将任务交给一堆工人，谁有空就谁就承担这个任务（线程池）。

### **1、继承Thread类创建线程** ###

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

public class MyThread extends Thread {  
    　　public void run() {  
    　　 System.out.println("MyThread.run()");  
    　　}  
    }  
     
    MyThread myThread1 = new MyThread();  
    MyThread myThread2 = new MyThread();  
    myThread1.start();  
    myThread2.start();

### **2、实现Runnable接口创建线程** ###

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口，如下：

public class MyThread extends OtherClass implements Runnable {  
    　　public void run() {  
    　　 System.out.println("MyThread.run()");  
    　　}  
    }

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

//重写子类run方法
    new Thread() {
    	public void run() {
    		System.out.println("thread start ..");
    	};
    }.start();
    		
    
    //传入Rannable实例，重写run方法。	
    new Thread(new Runnable() {
    	@Override
    	public void run() {
    		System.out.println("thread start ..");
    	}
    }).start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {  
    　　if (target != null) {  
    　　 target.run();  
    　　}  
    }

### 3、使用 FutureTask 实现有返回结果的线程 ###

与Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。

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

介绍了相关的概念之后，创建并启动有返回值的线程的步骤如下：

*  1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
 *  2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值。
 *  3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）。
 *  4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

public class Test {
      public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<Double> task = new FutureTask(new MyCallable());
        //创建一个线程，异步计算结果
        Thread thread = new Thread(task);
        thread.start();
        //主线程继续工作
        Thread.sleep(1000);
        System.out.println("主线程等待计算结果...");
        //当需要用到异步计算的结果时，阻塞获取这个结果
        Double d = task.get();
        System.out.println("计算结果是："+d);
    
        //用同一个 FutureTask 再起一个线程
        Thread thread2 = new Thread(task);
        thread2.start();
    }
    }
    
    class MyCallable implements Callable<Double>{
    
        @Override
        public Double call() {
             double d = 0;
             try {
                 System.out.println("异步计算开始.......");
                  d = Math.random()*10;
                 d += 1000;
                Thread.sleep(2000);
                 System.out.println("异步计算结束.......");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return d;
        }
    }

## 4、使用线程池例如用Executor框架 ##

1.5后引入的Executor框架的最大优点是把任务的提交和执行解耦。要执行任务的人只需把Task描述清楚，然后提交即可。这个Task是怎么被执行的，被谁执行的，什么时候执行的，提交的人就不用关心了。具体点讲，提交一个Callable对象给ExecutorService（如最常用的线程池ThreadPoolExecutor），将得到一个Future对象，调用Future对象的get方法等待执行结果就好了。Executor框架的内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免this逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象用Executor在构造器中。