Java并发编程:如何创建线程?

在 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<V> {
    /**
     * 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<V> {
    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<V> implements RunnableFuture<V>

   FutureTask类实现了RunnableFuture接口,我们看一下RunnableFuture接口的实现:

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

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

  FutureTask提供了2个构造器:

public FutureTask(Callable<V> 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<String>{
    @Override
    public String call() throws Exception {
        return "Hello Callable.";
    }
}
public class CallableThread {

    public static void main(String args[]) {
        Task task = new Task();
        FutureTask<String> 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<String>{
    @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<String> futureTask = new FutureTask<>(task);
        executor.submit(futureTask);
        executor.shutdown(); 

        //第2种方式
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<String> 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 类型对象。

参考资料:

http://www.cnblogs.com/lwbqqyumidi/p/3804883.html

http://www.cnblogs.com/mengdd/archive/2013/02/20/2917966.html

http://www.cnblogs.com/dolphin0520/p/3949310.html

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏大大的微笑

Future,带返回执行结果的线程使用方式

FutureTask是Future的一种实现方式. private final int count; public Counter(int count) {...

2567
来自专栏小樱的经验随笔

Educational Codeforces Round 21 D.Array Division(二分)

D. Array Division time limit per test:2 seconds memory limit per test:256 megaby...

36311
来自专栏逸鹏说道

Python3 与 C# 基础语法对比(List、Tuple、Dict专栏)

Python3 与 C# 基础语法对比(基础知识场):https://www.cnblogs.com/dotnetcrazy/p/9102030.html

943
来自专栏增长技术

Swift基础---Optionals

802
来自专栏逸鹏说道

Python3 与 C# 基础语法对比(List、Tuple、Dict专栏)

Python3 与 C# 基础语法对比(基础知识场):https://www.cnblogs.com/dotnetcrazy/p/9102030.html

24610
来自专栏闵开慧

java概念1

public static void main(String[] args) {//其中[]也可以写在args后面,args也可以随便写成其他字母,例如asd...

36111
来自专栏Java开发者杂谈

java如何获取一个对象的大小

When---什么时候需要知道对象的内存大小 在内存足够用的情况下我们是不需要考虑java中一个对象所占内存大小的。但当一个系统的内存有限,或者某块程序代码允许...

1.4K7
来自专栏null的专栏

设计模式——类图以及类与类之间的关系

    设计模式在程序设计上有着很重要的作用,使用设计模式可以使得代码更容易被理解,使得代码更规范,真正实现工程化。 一、用UML表示一个类 ? 类图一般是三行...

3694
来自专栏菩提树下的杨过

Flash/Flex学习笔记(8):ActionScript3.0中的面对对象

首先要习惯AS3.0的几个BT约定: 1.一个.as文件中,只能定义一个类 2.类名称必须与.as的文件名相同 3.类定义中必须要有package包声明 4.一...

1819
来自专栏Phoenix的Android之旅

深入分析ClassCastException

ClassCastException时常见,只要两个不同类强转换就会有这种问题,不过下面这种错误不知道见过没

601

扫码关注云+社区

领取腾讯云代金券