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

最新推荐文章于 2022-09-04 17:24:10 发布

Mungo

最新推荐文章于 2022-09-04 17:24:10 发布

阅读量502

点赞数 1

分类专栏：多线程文章标签：多线程

本文链接：https://blog.csdn.net/Mungo/article/details/77932666

版权

多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java线程创建的三种方式：

直接继承Thread类，重载run()方法
实现Runnable接口，重载run()方法
实现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();
            }

        }

    }