Java并发包——使用新的方式创建线程

Java并发包——使用新的方式创建线程

摘要：本文主要学习了如何使用Java并发包中的类创建线程。

部分内容来自以下博客：

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

使用Callable接口创建线程

Callable与Runnable

之前学习多线程的时候，使用java.lang包下的Runnable接口可以创建线程。

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

发现由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。

Callable位于java.util.concurrent包下，它是一个函数式接口，在它里面声明了一个方法，只不过这个方法叫做call()。

 @FunctionalInterface
 public interface Callable<V> {
     V call() throws Exception;
 }

通过源码可以看到call()方法是一个泛型接口，可以返回V类型的数据，并且支持抛出异常。

Future

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

Future类位于java.util.concurrent包下，它是一个接口：

 public interface Future<V> {
     // 用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。
     // 参数mayInterruptIfRunning表示是否允许取消正在执行的任务，如果设置true，则表示可以取消正在执行过程中的任务。
     // 如果任务已经完成，返回false。
     // 如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false。
     // 如果任务还没有执行，返回true。
     boolean cancel(boolean mayInterruptIfRunning);

     // 表示正在执行的任务是否被取消成功，如果在完成前被取消成功，返回true。
     boolean isCancelled();

     // 表示任务是否已经完成，若任务完成，则返回true。
     boolean isDone();

     // 用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回。
     V get() throws InterruptedException, ExecutionException;

     // 用来获取执行结果，如果在指定时间内，还没获取到结果，就抛出TimeoutException异常。
     V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
 }

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。

FutureTask

我们先来看一下FutureTask的实现：

 public class FutureTask<V> implements RunnableFuture<V>

FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：

 public interface RunnableFuture<V> extends Runnable, Future<V>

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

FutureTask提供了2个构造器：

public FutureTask(Callable<V> callable);

public FutureTask(Runnable runnable, V result);

创建线程并使用

代码如下：

 public class Demo {
     public static void main(String[] args) {
         FutureTask<Integer> futureTask = new FutureTask<Integer>(new NewFutureTask());
         new Thread(futureTask).start();
         try {
             Integer i = futureTask.get();
             System.out.println(i);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }

 class NewFutureTask implements Callable<Integer> {
     @Override
     public Integer call() throws Exception {
         System.out.println("call() ...");
         return 100;
     }
 }

运行结果如下：

 call() ...
 100

因为FutureTask实现了RunnableFuture接口，而RunnableFuture又继承了Runnable和Future接口，所以FutureTask可以看作是Runnable的一个实现类。

所以在创建线程的时候，代码 new Thread(futureTask).start(); 实际上是通过 public Thread(Runnable target) 方法创建的线程。

使用线程池创建线程

Executor

Executor接口是线程池的顶层接口，ExecutorService接口是Executor的子接口，而ThreadPoolExecutor类实现了ExecutorService接口，是线程池的核心类。

Executors类时线程池的一个工具类，里面提供了创建线程池的几个静态方法。

下面的代码展示了使用Executors类的newFixedThreadPool()方法创建一个固定长度的线程池，并向线程池中插入任务的操作：

 public class Demo {
     public static void main(String[] args) {
         ExecutorService threadPool = Executors.newFixedThreadPool(3);

         for (int i = 1; i <= 11; i++) {
             DemoThread dt = new DemoThread(i);
             threadPool.submit(dt);
         }
         threadPool.shutdown();
     }
 }

 class DemoThread implements Runnable {
     int taskNo = 0;

     public DemoThread(int taskNo) {
         this.taskNo = taskNo;
     }

     @SuppressWarnings("static-access")
     public void run() {
         try {
             System.out.println("task " + taskNo);
             Thread.currentThread().sleep(4000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

结果如下：

 task 1
 task 3
 task 2// 此处有等待。
 task 4
 task 5
 task 6// 此处有等待。
 task 7
 task 9
 task 8// 此处有等待。
 task 10
 task 11

结果说明：

可以看到因为设置的线程数为3，所以在创建了3个线程之后，将剩下的任务放在了任务队列里，当有任务执行完成之后再将其取出执行。