Java并发编程：如何创建线程？-白红宇

Java并发编程：如何创建线程？

阅读量：6714 次

发布时间：2019-06-25

本文共 7616 字，大约阅读时间需要 25 分钟。

在 Java 中创建线程的方式有两种：1）继承 Thread 类 2）实现 Runnable 接口 3）实现 FutureTask 接口

前两种方式创建的线程都无法获取线程的执行结果，而通过 FutureTask 方式实现的线程可以获取线程执行的结果。

一、继承Thread类

package com.chanshuyi.thread;public class ThreadDemo1 {    public static void main(String[] args) {        new MyThread().start();    }}class MyThread extends Thread{    @Override    public void run(){        System.out.println("Hello, I'm Thread Constructured by Thread");    }}

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

当然，你也可以使用匿名类的方式书写。

package com.chanshuyi.thread;public class ThreadDemo2 {    public static void main(String[] args) {        new Thread(){            @Override            public void run(){                System.out.println("Hello, I'm Thread Constructured by anonymous Thread.");            }        }.start();    }}

二、实现Runnable接口

该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

package com.chanshuyi.thread;class MyRunnable implements Runnable {    @Override    public void run() {        System.out.println("Hello, I'm Thread Constructured by Runnable");    }}public class ThreadDemo {    public static void main(String[] args) {        new Thread(new MyRunnable()).start();    }}

当然了，其实你也可以用匿名函数的写法，这种写法更加面向对象，推荐使用这种写法

package com.chanshuyi.thread;public class ThreadDemo4 {    public static void main(String[] args) {        new Thread(new Runnable(){            @Override             public void run(){                System.out.println("Hello, I'm Thread Constructured by anonymous Runnable");            }        }).start();    }}

三、两种实现方式的区别

相信以上两种创建新线程的方式大家都很熟悉了，那么 Thread 和 Runnable 之间到底是什么关系呢？我们首先来看一下下面这个例子。

package com.chanshuyi.thread;public class ThreadDemo5 {    public static void main(String args[]){        //输出：Thread is Running.        new Thread(        //放在new Thread()括号中的new Runnable，其实是构造了一个实现了Runnable接口的类                new Runnable(){                    public void run() {                        while(true){                            System.out.println("Runnable is Running.");                            try{                                Thread.sleep(1000);                            }                            catch(Exception e){                                e.printStackTrace();                            }                        }                    }                }        ){            //放再new Thread{}内的方法，其实是构建了一个继承了Thread类的子类            public void run() {            while(true){                System.out.println("Thread is Running.");                try{                    Thread.sleep(1000);                }                catch(Exception e){                    e.printStackTrace();                }            }        }        }.start();    }}

在这里我们即使用了一个继承Thread类的子类，又在此子类的声明中传入了实现了Runnable对象的类的实例，那么这个例子可以创建一个线程吗？

可以的话，那么新的线程到底执行哪一个方法体里的数据？

答案是执行继承了Thread类的子类中的run()方法，具体原因需要追溯到Thread类的源码里，这里就不深入研究了。你只要记住，如果哪个变态的面试官丢这道题给你，你就要记得是执行的是继承了Thread类的子类（MyThread）的run()方法！即上面打出的日志是：Thread is Running.

四、实现 FutureTask 接口

其实除了继承 Thread 类和实现 Runnable 接口可以实现线程之外，还可以通过 FutureTask 接口实现线程，这种方式与前两种的区别是它可以得到线程执行的返回值。

1）Callable 与 Runnable

先说一下java.lang.Runnable吧，它是一个接口，在它里面只声明了一个run()方法：

public interface Runnable {    public abstract void run();}

　　由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。

　　Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做call()：

public interface Callable
     
       {    /**     * Computes a result, or throws an exception if unable to do so.     *     * @return computed result     * @throws Exception if unable to compute a result     */    V call() throws Exception;}

　　可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。

2）Future

　　Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

　　Future类位于java.util.concurrent包下，它是一个接口：

public interface Future
     
       {    boolean cancel(boolean mayInterruptIfRunning);    boolean isCancelled();    boolean isDone();    V get() throws InterruptedException, ExecutionException;    V get(long timeout, TimeUnit unit)        throws InterruptedException, ExecutionException, TimeoutException;}

在Future接口中声明了5个方法，下面依次解释每个方法的作用：

cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。

isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。

isDone方法表示任务是否已经完成，若任务完成，则返回true；

get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；

get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

　　也就是说Future提供了三种功能：

　　1）判断任务是否完成；

　　2）能够中断任务；

　　3）能够获取任务执行结果。

　　因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。

3）FutureTask

　　我们先来看一下FutureTask的实现：

public class FutureTask
     
       implements RunnableFuture

　　FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：

public interface RunnableFuture
     
       extends Runnable, Future
      
        {    void run();}

　　可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

　　FutureTask提供了2个构造器：

public FutureTask(Callable
     
       callable) {}public FutureTask(Runnable runnable, V result) {}

　　事实上，FutureTask是Future接口的一个唯一实现类。

4）使用实例

上面说到 Callable 与 Runnable 的区别之一就是：Callable 可以返回线程的执行结果，而 Runnable 不可以。而从上面我们知道：Callable 接口是具体执行体，而 Task 接口则用于获取执行结果。那么 Callable 到底怎么用呢？

一般情况下，Callable 需要与 Thread 或 ExecutorService 配合使用。

1、Callable、Future 配合 Thread 使用

一般情况下都是用 FutureTask 来包装 Runnable 实例对象，之后在将 FutureTask 对象作为 Thread 类接口。

class Task implements Callable
     
      {    @Override    public String call() throws Exception {        return "Hello Callable.";    }}public class CallableThread {    public static void main(String args[]) {        Task task = new Task();        FutureTask
      
        futureTask = new FutureTask<>(task);        Thread thread = new Thread(futureTask);        thread.start();        try {            System.out.println("Result:" + futureTask.get());        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }    }}

2、Callable、Future 配合 ExecutorService 使用

配合 ExecutorService 使用有两种方式，一种是用 FutureTask 包装 Runnable 实例对象，之后作为 submit 方法参数。另一种是直接将 Runnable 实例对象作为 submit 方法参数，而用 Future 对象接收返回结果。

class Task implements Callable
     
      {    @Override    public String call() throws Exception {        return "Hello Callable.";    }}public class CallableThread {    public static void main(String args[]) {        //第1种方式        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        FutureTask
      
        futureTask = new FutureTask<>(task);        executor.submit(futureTask);        executor.shutdown();         //第2种方式        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        Future
       
         futureTask = executor.submit(task);        executor.shutdown();        try {            System.out.println("Result:" + futureTask.get());        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }    }}

从上面两种方式知道，无论采用哪种方式，传进 Thread 或 ExecutorService 里的参数都是 Runnable 类型的，而接收返回结果的都是 Future 类型对象。

参考资料：

转载于:https://www.cnblogs.com/chanshuyi/p/5331164.html

你可能感兴趣的文章