多线程/并发笔记:线程创建的三种方式

原创 2017年09月12日 11:01:50

Java线程创建的三种方式:

  1. 直接继承Thread类,重载run()方法
  2. 实现Runnable接口,重载run()方法
  3. 实现Callable接口,重载call()方法

run()和start()

在java中新建一个线程很简单,只要new一个Thread对象,然后通过调用start()方法即可。

Thread t1 = new Thread();
t1.start();

Thread有一个run()方法,在线程start()之后,该方法会新建一个线程,并让这个线程去调用Thread的run()方法。

Thread的run()方法也是可以直接被调用的。

Thread t1 = new Thread();
t1.run();

这样的写法编译虽然不会报错,但是要注意的是:不会新建一个线程,而是在当前线程中执行run()方法

Thread

以上调用start()方法虽然会创建一个新的线程,但是Thread的run()方法默认什么都没有做。因此,这个线程一启动就马上结束了。如果想让线程做些什么事情,就必须重载run()方法,将要的操作填进去。

public static class ThreadDemo extends Thread{
        @Override
        public void run() {
            System.out.println("Hi Thread"+":"+Thread.currentThread().getName());
        }
    }

执行

public static void main(String args[]) {
        Thread t1 = new Thread(new ThreadDemo());
        t1.start();
    }

        //匿名变量
        new Thread(){
            @Override
            public void run() {
                System.out.println("Hi Thread"+":"+Thread.currentThread().getName());
            }
        }.start();

Runnable

通过继承虽然可以创建一个线程,但是因为Java是单继承的,所以通常会才用实现Runnable接口的方式创建线程。
通过Runnable接口的定义可知,这是一个单方法接口,只有一个run()方法。

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

同时,Thread类有一个重要的构造方法:

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

这个构造方法传入一个Runnable接口的实例,在start()方法调用时,新线程会执行Runnable.run()方法。实际上,Thread.run()也是这样的。run()的源码为:

private Runnable target;

......

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

因此,使用Runnable接口告诉线程该做什么,更为合理。

public static class MyThread implements Runnable{

        @Override
        public void run() {
            System.out.println("Hi,Runnable"+":"+Thread.currentThread().getName());
        }
    }

执行

public static void main(String args[]) {
        Thread t2 = new Thread(new MyThread());
        t2.start();
    }

以上代码,即实现Runnable接口,并将该实例传入到Thread。

Callable

通过Callable接口的定义可知,这是一个单方法接口,只有一个call()方法,但是call()方法是可以有返回值的。这是一个泛型接口,call()函数返回的类型就是传递进来的V类型。这也是和Runnable接口最大的不同。
同时,call()方法可以抛出异常。

Future

Future是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。get方法会阻塞,直到任务返回结果。Future声明如下

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;
}
  • 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)能够获取任务执行结果。

RunnableFuture

RunnableFuture实现了Runnbale又实现了Futrue这两个接口

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

FutureTask

FutureTask是一个RunnableFuture接口的实现。

public class FutureTask<V> implements RunnableFuture<V> 

他有两个重要的构造方法:

public FutureTask(Callable<V> callable) {  
    if (callable == null)  
        throw new NullPointerException();  
    this.callable = callable;  
    this.state = NEW;       // ensure visibility of callable  
}  

public FutureTask(Runnable runnable, V result) {  
    this.callable = Executors.callable(runnable, result);  
    this.state = NEW;       // ensure visibility of callable  
} 

可以看到,Runnable注入会被Executors.callable()函数转换为Callable类型,即FutureTask最终都是执行Callable类型的任务。
他的适配器函数在Executors中的实现为:

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

RunnableAdapter适配器

static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

由于FutureTask实现了Runnable,因此它既可以通过Thread包装来直接执行,也可以提交给ExecuteService来执行。
并且还可以直接通过get()函数获取执行结果,该函数会阻塞,直到结果返回。因此FutureTask既是Future、
Runnable,又是包装了Callable,如果是Runnable最终也会被转换为Callable。

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;
}

简单示例

定义一个实现Callable 的操作类。

public static class MyThreadCall implements Callable {

        @Override
        public String call() throws Exception {
            System.out.println("Hi,Callable"+":"+Thread.currentThread().getName());
            Thread.sleep(2000); //耗时操作
            return Thread.currentThread().getName() + ",Runnable Done";
        }
    }

执行Callable的线程的方法可以借助FutureTask或者加入到线程池中。
首先使用FutureTash执行

    public static void main(String args[]) {

        MyThreadCall t3 = new MyThreadCall();
        try {
            FutureTask<String> ft = new FutureTask<String>(t3);
            new Thread(ft,"有返回值的线程").start();
            //执行完成,返回返回值
            while(!ft.isDone()){
                System.out.println(ft.get());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

在上面,FutureTash扮演监督的角色,主线程通过不断询问实现Callable的类对应的线程是否执行完毕,最后可以得到返回的结果。

另一种方式是使用线程池:

    public static void main(String args[]) {
            //创建线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        //结果存储容器
        List<Future<String>> futures = new ArrayList<Future<String>>();

        for (int i = 0; i < 10; i++) {
            //submit接受一个Callable<T>类型的参数,返回Future<T>结果
            futures.add(exec.submit(new MyThreadCall()));
        }
        exec.shutdown();

        for (Future<String> fs : futures){

            try {
                //get()用来获取执行结果,这个方法会产生阻塞,会一直等到任务执行完毕才返回
                System.out.println(fs.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

        }

    }

线程池的submit方法会返回一个Future,通过这个Future可以判断线程是否执行完毕,得到返回值。

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

多线程/并发笔记:线程池的创建--Executor框架

Java线程相关的类和接口大多在java.util.concurrent包下面,线程池的创建可以通过Executors定义的一些类方法获取各种线程池实例。 newSingleThreadExecuto...
  • Mungo
  • Mungo
  • 2017年09月14日 11:56
  • 109

多线程-创建线程的三种方式

一.通过继承Thread类实现 1.子类SubThread继承Thread 2.重写run()方法:子线程的执行体 3.创建子类SubThread,并调用start():启动线程 public...
  • neven7
  • neven7
  • 2014年12月10日 21:40
  • 408

多线程创建 方法一: NSThread 创建线程的三种方式

// // RootViewController.m // 多线程 // // Created by zm on 14-11-26. // Copyright (c) 2014年 practi...

Java多线程学习1,使用线程的三种方式

java使用线程有三种方式 1,创建一个类继承Thread类 示例代码 public class Thread1 { public static void main(String[] arg...

Java并发之神修炼之路---创建多线程的三种方式

清晨,阳光明媚,秋早早地就来到了“训练室”,刚进门,只见大师飞一般地敲着键盘,空格键如拍子一样打着节奏,宛如一首美妙的音乐。秋来到了大师身旁,拿出电脑开了机,大师瞅了一眼秋,说,“上次对多线程有了一个...

Java多线程与并发学习之(二):创建线程的方式

Java中创建线程有3种方式:     (1).继承Thread方式;     (2).实现Runnable接口;     (3).通过Callable接口和FutureTask类创建。       ...

java创建启动多线程的三种方式

线程的创建和启动    java使用Thread代表线程,所有的对象都是Thread类或其之类的实例 使用继承Tread类来启动多线程的基本步骤:   1.创建Thread类的子类,并重写run()方...

java 多线程的三种创建方式

创建线程的方法     1.新建类继承 Thread 类实现线程     2.通过实现接口 Runnable 实现创建线程     3.使用 ExecutionException、Callable、E...
  • niaonao
  • niaonao
  • 2016年08月08日 20:41
  • 482

线程笔记(多线程,异常)

  • 2009年09月07日 16:21
  • 29KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:多线程/并发笔记:线程创建的三种方式
举报原因:
原因补充:

(最多只允许输入30个字)