创建线程的四种方式
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();