创建线程的四种方式

1、extendds Thred类 .start()

2、implements Runnable接口 new Thread(new MyRun()).start();

3、ListenableFuture

4、CompletableFuture （推荐）

lambda表达式 new Thread(()->{}).start();

for(int i=0;i<100;i++){
    new Thread(()->{
        System.out.println(">>>>>>开始了1个线程"+new Date());
    }).start();
}

//通过join()方法使当前线程“阻塞”，等待指定线程执行完毕后继续执行。

举例：在线程thread2中，加上一句thread1.join()，其意义在于，当前线程2运行到此行代码时会进入阻塞状态，直到线程thread1执行完毕后，线程thread2才会继续运行，这就保证了线程thread1与线程thread2的运行顺序。

public class ThreadJoinDemo {
  public static void main(String[] args) throws InterruptedException {
    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("打开冰箱！");
      }
    });
 
    final Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          thread1.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("拿出一瓶牛奶！");
      }
    });
 
    final Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          thread2.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("关上冰箱！");
      }
    });
 
    //下面三行代码顺序可随意调整，程序运行结果不受影响，因为我们在子线程中通过“join()方法”已经指定了运行顺序。
    thread3.start();
    thread2.start();
    thread1.start();
 
  }
}

打开冰箱！

拿出一瓶牛奶！

关上冰箱！

CompletableFuture解决的问题（推荐）

参考文章：https://zhuanlan.zhihu.com/p/515993095

CompletableFuture是由Java 8引入的，在Java8之前我们一般通过Future实现异步。

Future用于表示异步计算的结果，只能通过阻塞或者轮询的方式获取结果，而且不支持设置回调方法，Java 8之前若要设置回调一般会使用guava的ListenableFuture，回调的引入又会导致臭名昭著的回调地狱（下面的例子会通过ListenableFuture的使用来具体进行展示）。

CompletableFuture对Future进行了扩展，可以通过设置回调的方式处理计算结果，同时也支持组合操作，支持进一步的编排，同时一定程度解决了回调地狱的问题。

下面将举例来说明

我们通过ListenableFuture、CompletableFuture来实现异步的差异。

假设有三个操作step1、step2、step3存在依赖关系，其中step3的执行依赖step1和step2的结果。

Future(ListenableFuture)的实现（回调地狱）如下：

ExecutorService executor = Executors.newFixedThreadPool(5);
ListeningExecutorService guavaExecutor = MoreExecutors.listeningDecorator(executor);
ListenableFuture<String> future1 = guavaExecutor.submit(() -> {
    //step 1
    System.out.println("执行step 1");
    return "step1 result";
});
ListenableFuture<String> future2 = guavaExecutor.submit(() -> {
    //step 2
    System.out.println("执行step 2");
    return "step2 result";
});
ListenableFuture<List<String>> future1And2 = Futures.allAsList(future1, future2);
Futures.addCallback(future1And2, new FutureCallback<List<String>>() {
    @Override
    public void onSuccess(List<String> result) {
        System.out.println(result);
        ListenableFuture<String> future3 = guavaExecutor.submit(() -> {
            System.out.println("执行step 3");
            return "step3 result";
        });
        Futures.addCallback(future3, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println(result);
            }        
            @Override
            public void onFailure(Throwable t) {
            }
        }, guavaExecutor);
    }

    @Override
    public void onFailure(Throwable t) {
    }}, guavaExecutor);

CompletableFuture的实现如下：

//创建线程池，防止主线程结束造成其他线程终止运行，可以指定线程池中线程的数量
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行step 1");
    return "step1 result";
}, executor);
CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行step 2");
    return "step2 result";
});
cf1.thenCombine(cf2, (result1, result2) -> {
    System.out.println(result1 + " , " + result2);
    System.out.println("执行step 3");
    return "step3 result";
}).thenAccept(result3 -> System.out.println(result3));

//关闭线程池
executor.shutdown();

显然，CompletableFuture的实现更为简洁，可读性更好。

整个流程的结束依赖于三个以上的步骤CF1、CF2、CF3、CF4、CF5，这种多元依赖可以通过allOf或anyOf方法来实现，区别是当需要多个依赖全部完成时使用allOf，当多个依赖中的任意一个完成即可时使用anyOf，如下代码所示：

//创建线程池，防止主线程结束造成其他线程终止运行，可以指定线程池中线程的数量
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(2000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("执行step 1");
    return "step1 result";
}, executor);
CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行step 2");
    return "step2 result";
}, executor);

CompletableFuture<String> cf3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行step 3");
    return "step3 result";
}, executor);

CompletableFuture<String> cf4 = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行step 4");
    return "step4 result";
}, executor);

CompletableFuture<String> cf5 = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行step 5");
    return "step5 result";
}, executor);

CompletableFuture<Void> cf6 = CompletableFuture.allOf(cf1,cf2,cf3, cf4, cf5);
CompletableFuture<String> result = cf6.thenApply(v -> {
    //这里的join并不会阻塞，因为传给thenApply的函数是在CF3、CF4、CF5全部完成时，才会执行 。
    String result1 = cf1.join();
    String result2 = cf2.join();
    String result3 = cf3.join();
    String result4 = cf4.join();
    String result5 = cf5.join();
    System.out.println(result1+","+result2+","+result3+","+result4+","+result5);
    //根据result3、result4、result5组装最终result;
    return "resultAll";
});

//关闭线程池
executor.shutdown();

多线程批量执行任务简单实例(CompletableFuture)

CompletableFuture解决的问题（推荐）

猜你喜欢