关闭

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

标签: 多线程
168人阅读 评论(0) 收藏 举报
分类:

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可以判断线程是否执行完毕,得到返回值。

1
0
查看评论

Java创建线程的三种方式及其对比

Java中创建线程主要有三种方式: 一、继承Thread类创建线程类 (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 (2)创建Thread子类的实例,即创建了线程对象。 (3)调用线程对...
  • shenggaofei
  • shenggaofei
  • 2016-09-23 20:54
  • 3952

java线程(1)——三种创建线程的方式

1、接口实现更灵活,java不支持多继承。在这方面,Runnable和Callable更有优势。 2、返回值问题。Runnable和Thread都不能有返回值,但Callable可以,而且支持多种类型的数据。
  • u010066934
  • u010066934
  • 2016-04-04 21:16
  • 1556

Java中线程的三种实现方式

Java中使用Thread代表线程类,所有的线程类都必须是Thread类或者其子类的实例。每个线程的作用就是完成一定的任务,即执行一段程序流。Java中使用线程执行体来表示这段程序流。 Java中线程的实现方式有如下三种: 1.继承Thread类 public class Thread exte...
  • FFFLLLLLL
  • FFFLLLLLL
  • 2016-08-21 22:39
  • 2228

创建线程的几种方法及比较

1、通过继承Thread类创建线程 (1).首先定义一个类去继承Thread父类,重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。 (2).直接创建一个ThreadTest类的对象,也可以利用多态性,变量声明为父类的类型。 (3).调用start方法,线程启动,隐含的...
  • u012470138
  • u012470138
  • 2016-11-21 10:17
  • 2576

java创建线程的三种方式及其对比

Java中创建线程主要有三种方式: 一、继承Thread类创建线程类 (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 (2)创建Thread子类的实例,即创建了线程对象。 (3)调用线程对象的start()方法来...
  • longshengguoji
  • longshengguoji
  • 2014-11-14 22:14
  • 90729

c++多线程创建的几种方式

c++创建多线程的几种方法(入门)
  • sinat_38347636
  • sinat_38347636
  • 2017-05-23 12:11
  • 774

创建线程的三种方式

一、继承Thread类+重写run()方法 启动:创建子类对象+对象.start() 二、实现Runnable接口+重写run方法 启动:使用静态代理 1)、创建真实角色 2)、创建代理角色 3)、调用start()方法 启动线程 通过实现Runnable接口实现多线程。(用到了静态代...
  • scgaliguodong123_
  • scgaliguodong123_
  • 2015-05-27 17:13
  • 6385

一心多用多线程-线程创建的三种方式

第一次了解java线程机制,记录一下线程启动的三种方式。 1.通过继承Thread类调用一个线程public class Thread1 extends Thread{ @Override public void run() { System.out.println(...
  • hayre
  • hayre
  • 2016-10-28 15:53
  • 169

创建线程的三种方式和区别

第一种创建方式: 继承Thread,并且重写run方法。package com.easytopit.thread; public class ExtendsThread extends Thread { @Override public void run() { for(int i = ...
  • HelianthS
  • HelianthS
  • 2016-07-09 15:37
  • 418

Java编程思想读书笔记一:并发

1. Thread.yield( )方法当调用yield()时,即在建议具有相同优先级的其他线程可以运行了,但是注意的是,仅仅是建议,没有任何机制保证你这个建议会被采纳 。一般情况下,对于任何重要的控制或者调用应用时,都不能依赖于yield()。这个方法经常被误用。2.Runnable接口当从Run...
  • xunzaosiyecao
  • xunzaosiyecao
  • 2017-01-31 20:41
  • 647