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

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值