今後のマルチスレッドデザインパターン

将来のデザインパターンの核となるアイデアは、シリアル、非同期および非同期コールバックの実行からビジネスロジックを実装することです

例1：

パッケージcom.dwz.concurrency2.chapter10。

パブリック クラスSyncInvoker {
     公共 静的 ボイドメイン（文字列[]引数）がスローInterruptedExceptionあるが{
        文字列の結果 = GET（）;
        System.out.println（結果）。
　　　　 System.out.println（ "私が行っています。"）;
    }
    
    プライベート 静的の文字列のget（）がスロー例外：InterruptedExceptionを{
        Thread.sleep（10_000L）。
        戻る「FINISH」を。
    }
}

テスト結果：あなたは私が行っています実装前に得られた結果を待たなければなりません。

最適化：我々は、get（で再取る主導する必要がある場合、実際の事業は、早期行使と呼ばれる）が返されたデータを取得します。

将来のインタフェース

パッケージcom.dwz.concurrency2.chapter9。

パブリック インターフェース将来<T> {
    
    T GET（）はスローInterruptedExceptionあるが、
}

FutureTaskインタフェース

パッケージcom.dwz.concurrency2.chapter9。

パブリック インターフェース FutureTask <T> {
    
    Tコール（）。
}

FutureService类

パッケージcom.dwz.concurrency2.chapter9。

輸入java.util.function.Consumer;

パブリック クラスFutureService {
    
    パブリック <T>将来<T>提出する（最終 FutureTask <T> タスク）{
        AsynFuture <T> asynfuture = 新しい AsynFuture <T> （）;
        新しいスレッド（（） - > {
            T結果 = task.call（）。
            asynfuture.done（結果）。
        }）。開始（）;
        リターンasynfuture。
    }
}

今後の実装クラスはAsynFutureです

パッケージcom.dwz.concurrency2.chapter9。

パブリック クラス AsynFuture <T> を実装フューチャー<T> {
     プライベート 揮発性 ブール =行って偽;
    
    プライベートT結果;
    
    公共 ボイド完了（T結果）{
         同期（本）{
             この .result = 結果。
            このの.done = 真;
            この.notifyAll（）;
        }
    }
    
    @オーバーライド
    公共 Tのget（）がスローInterruptedExceptionある{
         同期（これを{）
             中（！行なわ）{
                 この.WAIT（）;
            }
        }
        戻り値の結果;
    }
    
}

テストカテゴリ

パッケージcom.dwz.concurrency2.chapter10。

パブリック クラスSyncInvoker {
     公共 静的 ボイドメイン（文字列[]引数）がスローInterruptedExceptionあるが{
        FutureService futureservice = 新しいFutureService（）;
        将来の <文字列>未来= futureservice.submit（（） - > { 
　　　　　　　//具体业务
             試し{
                Thread.sleep（10_000L）。
            } キャッチ（InterruptedExceptionある電子）{
                e.printStackTrace（）;
            }
            戻る「FINISH」を。
        }）;
        
        System.out.println（ "======================" ）;
        System.out.println（ "他のことをやります。" ）;
        System.out.println（ "***********************" ）;
        System.out.println（future.get（））。
        System.out.println（ "私が行っています。" ）;
    }
}

テスト結果：我々は）（トランザクション完了時のコールfuture.getの値を返す想定を満たすために取得する必要があるときに最初の呼び出しは、業務を処理するためにfutureservice.submit

最適化II：データ処理の完了は、我々は自分自身のリターンを呼び出すためのイニシアチブをとることを必要としない後、コールバックコールバックを増加

変更FutureServiceクラス、増加の消費者のプルバック

公共 <T>の未来<T>提出（最終 FutureTask <T>タスク、最終消費者<T> 消費者）{
        AsynFuture <T> asynfuture = 新しい AsynFuture <T> （）;
        新しいスレッド（（） - > {
            T結果 = task.call（）。
            asynfuture.done（結果）。
            consumer.accept（結果）。
        }）。開始（）;
        リターンasynfuture。
    }

若しくは

公共 <T> のボイド提出（最終 FutureTask <T>タスク、最終消費者<T> 消費者）{
        AsynFuture <T> asynfuture = 新しい AsynFuture <T> （）;
        新しいスレッド（（） - > {
            T結果 = task.call（）。
            asynfuture.done（結果）。
            consumer.accept（結果）。
        }）。開始（）;
    }

テスト

パッケージcom.dwz.concurrency2.chapter9。
/ **
 *フューチャー - >資格未来を表し
 * FutureTask  - >あなたのコール・ロジックの分離
 * FutureService->桥接今後の和FutureTask
 * / 
パブリック クラスSyncInvoker {
     公共 静的 ボイドメイン（文字列[]引数）がスローInterruptedExceptionあるが{ 
        FutureService futureservice = 新しいFutureService（）。
        futureservice.submit（（） - > {
             // 特定のサービス
            のtry {
                Thread.sleep（10_000L）。
            } キャッチ（InterruptedExceptionある電子）{
                e.printStackTrace（）;
            }
            戻る「FINISH」を。
        }のSystem.out ::のprintln）。
        
        System.out.println（ "===================" ）;
        System.out.println（ "他のことをやります。" ）;
        Thread.sleep（ 2000L ）。
        System.out.println（ "**********************" ）;
        System.out.println（ "syncinvokerが行われます。" ）;
    } 
}

テスト結果：需要を満たすために

参考動画：https://www.bilibili.com/video/av51503134?p=6 0

今後のマルチスレッドデザインパターン

おすすめ