org.apache.coyote

## Class AsyncStateMachine<S>

- java.lang.Object
- - org.apache.coyote.AsyncStateMachine<S>

-     public class AsyncStateMachine<S>
      extends Object

  Manages the state transitions for async requests.

       The internal states that are used are:
       DISPATCHED       - Standard request. Not in Async mode.
       STARTING         - ServletRequest.startAsync() has been called but the
                          request in which that call was made has not finished
                          processing.
       STARTED          - ServletRequest.startAsync() has been called and the
                          request in which that call was made has finished
                          processing.
       MUST_COMPLETE    - ServletRequest.startAsync() followed by complete() have
                          been called during a single Servlet.service() method. The
                          complete() will be processed as soon as the request
                          finishes.
       COMPLETE_PENDING - ServletRequest.startAsync() has been called and before the
                          request in which that call was had finished processing,
                          complete() was called for a non-container thread. The
                          complete() will be processed as soon as the request
                          finishes. This is different to MUST_COMPLETE because of
                          differences required to avoid race conditions during error
                          handling.
       COMPLETING       - The call to complete() was made once the request was in
                          the STARTED state. May or may not be triggered by a
                          container thread - depends if start(Runnable) was used.
       TIMING_OUT       - The async request has timed out and is waiting for a call
                          to complete(). If that isn't made, the error state will
                          entered.
       MUST_DISPATCH    - ServletRequest.startAsync() followed by dispatch() have
                          been called during a single Servlet.service() method. The
                          dispatch() will be processed as soon as the request
                          finishes.
       DISPATCH_PENDING - ServletRequest.startAsync() has been called and before the
                          request in which that call was had finished processing,
                          dispatch() was called for a non-container thread. The
                          dispatch() will be processed as soon as the request
                          finishes. This is different to MUST_DISPATCH because of
                          differences required to avoid race conditions during error
                          handling.
       DISPATCHING      - The dispatch is being processed.
       MUST_ERROR       - ServletRequest.startAsync() has been called followed by an
                          I/O error on a non-container thread. The main purpose of
                          this state is to prevent additional async actions
                          (complete(), dispatch() etc.) on the non-container thread.
                          The container will perform the necessary error handling,
                          including ensuring that the AsyncLister.onError() method
                          is called.
       ERROR            - Something went wrong.

       |-----------------»------|  |--«--------MUST_ERROR---------------«------------------------|
       |                       \|/\|/                                                            |
       |   |----------«-----E R R O R<-------------------------«-------------------------------| |
       |   |      complete() /|\/|\\ \--«---------------------------------«-----|              | ^
       |   |                  |  |  \                                           |              | |
       |   |    |-----»-------|  |   \-----------»----------|                   |              | |
       |   |    |                |                          |dispatch()         |              | |
       |   |    |                |                         \|/                  ^              | |
       |   |    |                |          |--|timeout()   |                   |              | |
       |   |    |     post()     |          | \|/           |     post()        |              | |
       |   |    |    |---------- | -->DISPATCHED<---------- | --------------COMPLETING<-----|  | |
       |   |    |    |           |   /|\/|\ |               |                | /|\ /|\      |  | |
       |   |    |    |    |---»- | ---|  |  |startAsync()   |       timeout()|--|   |       |  | |
       |   |    ^    ^    |      |       |  |               |                       |       |  ^ |
       |   |    |    |    |   |-- \ -----|  |   complete()  |                       |post() |  | |
       |   |    |    |    |   |    \        |     /--»----- | ---COMPLETE_PENDING-»-|       |  | |
       |   |    |    |    |   |     \       |    /          |                               |  | |
       |   |    |    |    |   ^      \      |   /           |                               |  | |
       |  \|/   |    |    |   |       \    \|/ /   post()   |                               |  | |
       | MUST_COMPLETE-«- | - | --«----STARTING--»--------- | -------------|                ^  | |
       |         /|\      |   |  complete()  | \            |              |     complete() |  | |
       |          |       |   |              |  \           |    post()    |     /----------|  | |
       |          |       ^   |    dispatch()|   \          |    |-----|   |    /              | |
       |          |       |   |              |    \         |    |     |   |   /               | |
       |          |       |   |             \|/    \        |    |    \|/ \|/ /                | ^
       |          |       |   |--«--MUST_DISPATCH-----«-----|    |--«--STARTED---»-------------| |
       |          |       | dispatched() /|\   |     \                / |     \                  |
       |          |       |               |    |      \              /  |      \  nct-io-error   |
       |          |       |               |    |       \            /   |       \----»-----------|
       |          |       |               |    |post()  \           |   |
       ^          ^       |               |    |       \|/          |   |
       |          |       ^               |    |  DISPATCH_PENDING  |   |
       |          |       |               |    |  |post()           |   |
       |          |       |               |    |  |      |----------|   |
       |          |       |               |    |  |      |  dispatch()  |
       |          |       |               |    |  |      |              |
       |          |       |post()         |    |  |      |     timeout()|
       |          |       |dispatched()   |   \|/\|/    \|/             |
       |          |       |---«---------- | ---DISPATCHING              |
       |          |                       |     |    ^                  |
       |          |                       |     |----|                  |
       |          |                       |    timeout()                |
       |          |                       |                             |
       |          |                       |       dispatch()           \|/
       |          |                       |-----------«-----------TIMING_OUT
       |          |                                                 |   |
       |          |-------«----------------------------------«------|   |
       |                              complete()                        |
       |                                                                |
       |<--------«-------------------«-------------------------------«--|
                                       error()

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `AsyncStateMachine(Processor<S> processor)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `asyncComplete()`
    `boolean` | `asyncDispatch()`
    `void` | `asyncDispatched()`
    `boolean` | `asyncError()`
    `void` | `asyncMustError()`
    `AbstractEndpoint.Handler.SocketState` | `asyncPostProcess()`
    `void` | `asyncRun(Runnable runnable)`
    `void` | `asyncStart(AsyncContextCallback asyncCtxt)`
    `boolean` | `asyncTimeout()`
    `boolean` | `isAsync()`
    `boolean` | `isAsyncDispatching()`
    `boolean` | `isAsyncError()`
    `boolean` | `isAsyncStarted()`
    `boolean` | `isAsyncTimingOut()`
    `boolean` | `isCompleting()`
    `void` | `recycle()`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### AsyncStateMachine

          public AsyncStateMachine(Processor<S> processor)

  - ### Method Detail

    - #### isAsync

          public boolean isAsync()

    - #### isAsyncDispatching

          public boolean isAsyncDispatching()

    - #### isAsyncStarted

          public boolean isAsyncStarted()

    - #### isAsyncTimingOut

          public boolean isAsyncTimingOut()

    - #### isAsyncError

          public boolean isAsyncError()

    - #### isCompleting

          public boolean isCompleting()

    - #### asyncStart

          public void asyncStart(AsyncContextCallback asyncCtxt)

    - #### asyncPostProcess

          public AbstractEndpoint.Handler.SocketState asyncPostProcess()

    - #### asyncComplete

          public boolean asyncComplete()

    - #### asyncTimeout

          public boolean asyncTimeout()

    - #### asyncDispatch

          public boolean asyncDispatch()

    - #### asyncDispatched

          public void asyncDispatched()

    - #### asyncMustError

          public void asyncMustError()

    - #### asyncError

          public boolean asyncError()

    - #### asyncRun

          public void asyncRun(Runnable runnable)

    - #### recycle

          public void recycle()

Copyright © 2000-2017 Apache Software Foundation. All Rights Reserved.