Tomcat が非同期サーブレットを実装する方法の詳細な説明

@WebServlet(urlPatterns = "/async",asyncSupported = true)
翻訳者
パブリッククラスAsyncServletはHttpServletを拡張します{

 ExecutorService executorService =Executors.newSingleThreadExecutor();

 @オーバーライド
  保護された void doGet(HttpServletRequest req, HttpServletResponse resp) は ServletException、IOException をスローします {
  //非同期を開始し、非同期コンテキストを取得します。final AsyncContext ctx = req.startAsync();
  // スレッドプールの非同期実行を送信します。executorService.execute(new Runnable() {


   @オーバーライド
   パブリックボイド実行() {
    試す {
     log.info("非同期サービスの実行準備ができました");
     //時間のかかるタスクをシミュレートする Thread.sleep(10000L);
     ctx.getResponse().getWriter().print("非同期サーブレット");
     log.info("非同期サービスが実行されました");
    } キャッチ (IOException e) {
     e.printStackTrace();
    } キャッチ (InterruptedException e) {
     e.printStackTrace();
    }
    //最後に、実行が完了するとコールバックが完了します。
    ctx.complete();
   }
  });
 }

 パブリックAsyncContext startAsync(ServletRequest リクエスト、
   ServletResponse レスポンス) {
  （！isAsyncSupported()）の場合{
   不正な状態例外 ise =
     新しい IllegalStateException(sm.getString("request.asyncNotSupported"));
   log.warn(sm.getString("coyoteRequest.noAsync",
     StringUtils.join(getNonAsyncClassNames()))、ise);
   投げる
  }

  （asyncContext == null）の場合{
   asyncContext = 新しい AsyncContextImpl(this);
  }

  asyncContext.setStarted(getContext(), リクエスト, レスポンス,
    リクエスト==getRequest() && レスポンス==getResponse().getResponse());
  asyncContext.setTimeout(getConnector().getAsyncTimeout());

  asyncContext を返します。
 }

 パブリックボイドコンプリート（）{
  ログがデバッグ有効の場合
   logDebug("完了 ");
  }
  チェック（）;
  リクエスト.getCoyoteRequest().action(ActionCode.ASYNC_COMPLETE, null);
 }
//クラス: AbstractProcessor 
 パブリックファイナルボイドアクション(アクションコードアクションコード、オブジェクトパラメータ) {
 ASYNC_COMPLETEの場合: {
   ディスパッチをクリアします。
   （asyncStateMachine.asyncComplete()）の場合{
    SocketEvent を処理します (SocketEvent.OPEN_READ、true)。
   }
   壊す;
  } 
 }
 //クラス: AbstractProcessor 
保護されたvoid processSocketEvent(SocketEventイベント、ブールディスパッチ) {
  SocketWrapperBase<?> socketWrapper = getSocketWrapper();
  ソケットラッパーが null の場合
   socketWrapper.processSocket(イベント、ディスパッチ);
  }
 }
 //クラス: AbstractEndpoint
パブリックブール型プロセスソケット(SocketWrapperBase<S> socketWrapper,
   SocketEvent イベント、ブールディスパッチ）{
  //一部のコードを省略 SocketProcessorBase<S> sc = null;
   プロセッサキャッシュが null の場合
    sc = プロセッサキャッシュ.pop();
   }
   （sc == null）の場合{
    sc = createSocketProcessor(socketWrapper、イベント);
   } それ以外 {
    sc.reset(socketWrapper、イベント);
   }
   実行者 executor = getExecutor();
   if (ディスパッチ && エグゼキュータ != null) {
    実行者.execute(sc);
   } それ以外 {
    sc.run();
   }
 
  true を返します。
 }

クラス: AbstractProcessorLight
パブリック SocketState プロセス (SocketWrapperBase<?> socketWrapper、SocketEvent ステータス)
   IOException をスローします {
  //直径の一部を省略
  SocketState 状態 = SocketState.CLOSED;
  イテレータ<DispatchType> ディスパッチ = null;
  する {
   if (ディスパッチ!= null) {
    ディスパッチタイプ nextDispatch = dispatches.next();
    状態 = ディスパッチ(nextDispatch.getSocketStatus());
   } そうでない場合 (ステータス == SocketEvent.DISCONNECT) {
   
   } そうでない場合 (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {
    状態 = ディスパッチ(ステータス);
    状態 == SocketState.OPEN の場合 {
     状態 = サービス(socketWrapper);
    }
   } そうでない場合 (ステータス == SocketEvent.OPEN_WRITE) {
    状態 = SocketState.LONG;
   } それ以外の場合 (ステータス == SocketEvent.OPEN_READ) {
    状態 = サービス(socketWrapper);
   } それ以外 {
    状態 = SocketState.CLOSED;
   }

  } while (state == SocketState.ASYNC_END ||
    ディスパッチ != null && 状態 != SocketState.CLOSED);

  状態を返します。
 }

パブリックブールasyncDispatch(org.apache.coyote.Request req, org.apache.coyote.Response res,
   SocketEventステータス）例外をスローします{
  //一部のコードを省略 Request request = (Request) req.getNote(ADAPTER_NOTES);
  レスポンス response = (レスポンス) res.getNote(ADAPTER_NOTES);
  ブール値の成功 = true;
  AsyncContextImpl は、リクエストの getAsyncContextInternal() を返します。
  試す {
   リクエストが非同期の場合
    レスポンスを一時停止に設定します(false);
   }

   （ステータス==SocketEvent.TIMEOUT）の場合{
    （！asyncConImpl.timeout()）の場合{
     asyncConImpl.setErrorState(null、false);
    }
   } そうでない場合 (ステータス == SocketEvent.ERROR) {
    
   }

   リクエストが非同期ディスパッチされている場合、
    書き込みリスナー writeListener = res.getWriteListener();
    ReadListener の readListener = req.getReadListener();
    if (writeListener != null && status == SocketEvent.OPEN_WRITE) {
     クラスローダー oldCL = null;
     試す {
      oldCL = request.getContext().bind(false, null);
      res.onWritePossible(); //ここでブラウザのレスポンスを実行し、データを書き込みます if (request.isFinished() && req.sendAllDataReadEvent() &&
        readListener != null) {
       readListener.onAllDataRead();
      }
     } キャッチ (Throwable t) {
      
     ついに
      リクエスト.getContext().unbind(false, oldCL);
     }
    } 
    }
   }
   //ここでは非同期が進行中であると判断されます。つまり、これは完了メソッドのコールバックではなく、通常の非同期リクエストであり、コンテナは引き続き呼び出されます。
   リクエストが非同期にディスパッチされるかどうか
    コネクタ.getService().getContainer().getPipeline().getFirst().invoke()
      リクエスト、レスポンス);
    Throwable t = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);
    t != nullの場合{
     asyncConImpl.setErrorState(t, true);
    }
   }
   //ここで、タイムアウトまたはエラーが発生した場合、request.isAsync() は false を返し、できるだけ早くクライアントにエラーを出力することに注意してください。
   リクエストが非同期の場合
    //これも出力ロジック request.finishRequest();
    レスポンスを終了します。
   }
   //リクエストとレスポンスを破棄する
   if (!成功 || !request.isAsync()) {
    updateWrapperErrorCount(リクエスト、レスポンス);
    リクエスト.recycle();
    レスポンスをリサイクルします。
   }
  }
  成功を返します。
 }

 postParseSuccess = postParseRequest(req、リクエスト、res、応答);
   //一部のコードを省略 if (postParseSuccess) {
    リクエスト.setAsyncSupported()
      コネクタ.getService().getContainer().getPipeline().isAsyncSupported());
    コネクタ.getService().getContainer().getPipeline().getFirst().invoke()
      リクエスト、レスポンス);
   }
   リクエストが非同期の場合
    非同期 = true;
    } それ以外 {
    // クライアントにデータを出力 request.finishRequest();
    レスポンスを終了します。
   非同期の場合
    updateWrapperErrorCount(リクエスト、レスポンス);
    //リクエストとレスポンスを破棄する
    リクエスト.recycle();
    レスポンスをリサイクルします。
   }

@レストコントローラ
翻訳者
パブリッククラスTestController{
 オートワイヤード
 プライベート TestService サービス。

 @GetMapping("/hello")
 パブリック文字列テスト（）{
  試す {
   log.info("testAsynch 開始");
   完了可能なFuture<String> test1 = service.test1();
   完了可能なFuture<String> test2 = service.test2();
   完了可能なFuture<String> test3 = service.test3();
   テスト1、テスト2、テスト3の完了可能なFuture。
   ログ情報("test1=====" + test1.get());
   ログ情報("test2=====" + test2.get());
   ログ情報("test3=====" + test3.get());
  } キャッチ (InterruptedException e) {
   e.printStackTrace();
  } キャッチ (ExecutionException e) {
   e.printStackTrace();
  }
  「hello」を返します。
 }
@サービス
パブリッククラスTestService{
 @Async("asyncExecutor")
 パブリックCompletableFuture<String> test1()はInterruptedExceptionをスローします{
  スレッドスリープ(3000L);
  CompletableFuture.completedFuture("test1") を返します。
 }

 @Async("asyncExecutor")
 パブリックCompletableFuture<String> test2()はInterruptedExceptionをスローします{
  スレッドスリープ(3000L);
  CompletableFuture.completedFuture("test2") を返します。
 }

 @Async("asyncExecutor")
 パブリックCompletableFuture<String> test3()はInterruptedExceptionをスローします{
  スレッドスリープ(3000L);
  CompletableFuture.completedFuture("test3") を返します。
 }
}
@SpringBootアプリケーション
@非同期を有効にする
パブリッククラスTomcatdebugApplication {

 パブリック静的voidメイン(String[] args) {
  TomcatdebugApplication.class を SpringApplication.run します。
 }

 @Bean(名前 = "asyncExecutor")
 パブリックエグゼキュータ asyncExecutor() {
  ThreadPoolTask​​Executor 実行プログラム = 新しい ThreadPoolTask​​Executor();
  executor.setCorePoolSize(3);
  実行者.setMaxPoolSize(3);
  実行者.setQueueCapacity(100);
  executor.setThreadNamePrefix("AsynchThread-");
  実行者を初期化します。
  実行者を返す。
 }