スレッドのシリアル化方法
単一タスク
これはCompletablefuturecの戻り結果を感知できないもので、ここで前のスレッドタスクはCompletablefuturecでなければなりません.
このCompletablefuturecの戻り結果を感知できるConsumer superは、前のCompletablefutureの実行結果actionが次に処理するタスクを表す
これは,前のスレッドタスクが終了した戻り値を感知するだけでなく,自分の現在のタスクが終了した後も同様に戻り値を持って外に出ることができる.
2つのタスクの組合せ-すべて完了します.
タスク1とタスク2の実行が完了するとタスク3が実行されるが、タスク3はタスク1、タスク2のタスクの実行が完了したことしか感知できず、結果が得られない
タスク1、タスク2の実行が完了すると、タスク3は、タスク1、タスク2の実行が完了したことを感知し、戻り値を得ることができるが、タスク3は値を返すことができない
タスク1、タスク2の実行が完了すると、タスク3は感知でき、タスク1、タスク2の値を持つことができ、タスク3は自分で値を返すことができる.
2つのタスクの組み合わせ-いずれかが完了します.
タスクの終了のみを感知し、2つのタスクの実行結果を感知できない
2つのタスクで先に実行したタスクの実行結果を感知する
2つのタスクで先に実行したタスクの実行結果を感知し、値を返すことができます.
マルチタスクコンビネーション
タスクがすべて実行されるのを待っています.ここのタスクは並列に実行されます.
いずれかのタスクの実行が完了した後に終了するのを待つ
実際のシーン
このインタフェースはユーザAを取得し、ユーザB間で注目しているかどうか、ブラックアウトしているかどうか、注目しているかどうか、ブラックアウト操作は2回のデータベースに入る必要があるため、一般的には注目しているかどうかを調べ、下にクエリーを実行してブラックアウトしているかどうかを書くのが一般的である.では、タスク編成を使用すると、100ミリ秒で完了します!!!
これはCompletablefuturecの戻り結果を感知できないもので、ここで前のスレッドタスクはCompletablefuturecでなければなりません.
// Completablefuturec ， Completablefuturec
//public Completionstage thenRun (Runnable action);// Async
//public Completionstage thenRunAsync (Runnable action);// Async
//public Completionstage thenRunAsync (Runnable action, Executor executor);// Async ，
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
System.out.println(" ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
},executorService).thenRunAsync(()->{
System.out.println(" 2 ");
System.out.println(" ID-->" + Thread.currentThread().getId());
},executorService);
このCompletablefuturecの戻り結果を感知できるConsumer superは、前のCompletablefutureの実行結果actionが次に処理するタスクを表す
// Completablefuturec Consumer super Completablefuture action
//public Completionstage thenAccept (Consumer < ? super T > action);
//public Completionstage thenAcceptAsync(Consumer < ? super T > action);
//public Completionstage thenAcceptAsync (Consumer < ? super T > action, Executor executor);
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
System.out.println(" ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
},executorService).thenAcceptAsync(res->{
System.out.println(" ID-->" + Thread.currentThread().getId());
System.out.println(" 2 ");
System.out.println(res);
},executorService);
これは,前のスレッドタスクが終了した戻り値を感知するだけでなく,自分の現在のタスクが終了した後も同様に戻り値を持って外に出ることができる.
// ， ，
// T ，U ，fn
//public Completablefuture thenApply (Functionc ? super T,? extends Us fn)
//public CompletableFuturec thenApplyAsync(Function ? super T, ? extends Us fn)
//public Completablefuturec thenApplyAsync(Functionc ? super T, ? extends U > fn, Executor executor)
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
System.out.println(" ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
}, executorService);
future.thenApplyAsync(res->{
System.out.println(" ID-->" + Thread.currentThread().getId());
System.out.println(" 2 ");
System.out.println(res);
return 10;
},executorService);
System.out.println(future.get());
2つのタスクの組合せ-すべて完了します.
タスク1とタスク2の実行が完了するとタスク3が実行されるが、タスク3はタスク1、タスク2のタスクの実行が完了したことしか感知できず、結果が得られない
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
return i;
}, executorService);
future1.runAfterBothAsync(future2, () -> {
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
}, executorService);
タスク1、タスク2の実行が完了すると、タスク3は、タスク1、タスク2の実行が完了したことを感知し、戻り値を得ることができるが、タスク3は値を返すことができない
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
return i;
}, executorService);
future1.thenAcceptBothAsync(future2,(f1,f2)->{
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
System.out.println(" 1 ："+f1);
System.out.println(" 2 ："+f2);
},executorService);
タスク1、タスク2の実行が完了すると、タスク3は感知でき、タスク1、タスク2の値を持つことができ、タスク3は自分で値を返すことができる.
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
return i;
}, executorService);
CompletableFuture<Integer> future3 = future1.thenCombineAsync(future2, (f1, f2) -> {
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
System.out.println(" 1 ："+f1);
System.out.println(" 2 ："+f2);
return f1 + f2;
}, executorService);
System.out.println(future3.get());
2つのタスクの組み合わせ-いずれかが完了します.
タスクの終了のみを感知し、2つのタスクの実行結果を感知できない
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
return i;
}, executorService);
future1.runAfterEitherAsync(future2,()->{
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
},executorService);
2つのタスクで先に実行したタスクの実行結果を感知する
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
return i;
}, executorService);
future1.acceptEitherAsync(future2,(res)->{
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
System.out.println(" "+res);
},executorService);
2つのタスクで先に実行したタスクの実行結果を感知し、値を返すことができます.
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
return i;
}, executorService);
CompletableFuture<Integer> future3 = future1.applyToEitherAsync(future2, (res) -> {
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
System.out.println(" " + res);
return res + 10;
}, executorService);
System.out.println(future3.get());
マルチタスクコンビネーション
タスクがすべて実行されるのを待っています.ここのタスクは並列に実行されます.
System.out.println(" ");
long t1=new Date().getTime();
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return i;
}, executorService);
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int i = 10 / 5;
return i;
}, executorService);
CompletableFuture<Void> conformityF = CompletableFuture.allOf(future1, future2, future3);
conformityF.get();//
System.out.println(" 1 -->"+future1.get());
System.out.println(" 2 -->"+future2.get());
System.out.println(" 3 -->"+future3.get());
System.out.println(new Date().getTime()-t1);
System.out.println(" ");
いずれかのタスクの実行が完了した後に終了するのを待つ
System.out.println(" ");
long t1=new Date().getTime();
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 1， ID-->" + Thread.currentThread().getId());
int i = 10 / 1;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return i;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 2， ID-->" + Thread.currentThread().getId());
int i = 10 / 2;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return i;
}, executorService);
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
System.out.println(" 3， ID-->" + Thread.currentThread().getId());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int i = 10 / 5;
return i;
}, executorService);
CompletableFuture<Object> conformityF = CompletableFuture.anyOf(future1, future2, future3);
conformityF.get();//
System.out.println(" -->"+conformityF.get());//
System.out.println(new Date().getTime()-t1);
System.out.println(" ");
実際のシーン
@Override
public String doPost(ChannelHandlerContext ctx, FullHttpRequest request, JSONObject params) {
Out.debug("--------------- - ----------------");
String userId=params.getString("userId");
String tagId=params.getString("tagId");
CompletableFuture<Integer> t1 = CompletableFuture.supplyAsync(() -> {
return UserFollowDB.getCountByUid(userId,tagId);// 0. 1.
});
CompletableFuture<Integer> t2 = CompletableFuture.supplyAsync(() -> {
return UserBlacklistDB.getCountByUserId(userId, tagId) == true ? 1 : 0;// 0. 1.
});
CompletableFuture<JSONObject> t3 = t1.thenCombineAsync(t2, (f1, f2) -> {
JSONObject res = new JSONObject();
res.put("isAttention", f1);
res.put("isBlock", f2);
return res;
});
JSONObject res=null;
try {
res=t3.get();
} catch (InterruptedException e) {
return error(ErrorCodeList.SERVER_ERROR);
} catch (ExecutionException e) {
e.printStackTrace();
return error(ErrorCodeList.SERVER_ERROR);
}
return success(res);
}
このインタフェースはユーザAを取得し、ユーザB間で注目しているかどうか、ブラックアウトしているかどうか、注目しているかどうか、ブラックアウト操作は2回のデータベースに入る必要があるため、一般的には注目しているかどうかを調べ、下にクエリーを実行してブラックアウトしているかどうかを書くのが一般的である.では、タスク編成を使用すると、100ミリ秒で完了します!!!