anchor.diff:  	}
   ----
   
  -A second option is for the controller to return an instance of `DeferredResult`. In this
  -case the return value will also be produced from a separate thread. However, that thread
  -is not known to Spring MVC. For example the result may be produced in response to some
  -external event such as a JMS message, a scheduled task, etc. Here is an example
  -controller method:
  +Another option is for the controller method to return an instance of `DeferredResult`. In this
  +case the return value will also be produced from any thread, i.e. one that
  +is not managed by Spring MVC. For example the result may be produced in response to some
  +external event such as a JMS message, a scheduled task, and so on. Here is an example
  +of such a controller method:
   
   [source,java,indent=0]
   [subs="verbatim,quotes"]
  
positive.code: 
  ----
  
  If using Servlet 3, Java based configuration, e.g. via `WebApplicationInitializer`,
  you'll also need to set the "asyncSupported" flag as well as the ASYNC dispatcher type
  just like with `web.xml`. To simplify all this configuration, consider extending
  `AbstractDispatcherServletInitializer` or
  `AbstractAnnotationConfigDispatcherServletInitializer`, which automatically set those
  options and make it very easy to register `Filter` instances.
  
  [[mvc-ann-async-configuration-spring-mvc]]
  ===== Spring MVC Async Config
  The MVC Java config and the MVC namespace both provide options for configuring async
  request processing. `WebMvcConfigurer` has the method `configureAsyncSupport` while
  <mvc:annotation-driven> has an <async-support> sub-element.
  
  Those allow you to configure the default timeout value to use for async requests, which
  if not set depends on the underlying Servlet container (e.g. 10 seconds on Tomcat). You
  
negative.code: === Asynchronous Request Processing
  Spring MVC 3.2 introduced Servlet 3 based asynchronous request processing. Instead of
  returning a value, as usual, a controller method can now return a
  `java.util.concurrent.Callable` and produce the return value from a Spring MVC managed thread.
  Meanwhile the main Servlet container thread is exited and released and allowed to process other
  requests. Spring MVC invokes the `Callable` in a separate thread with the help of a
  `TaskExecutor` and when the `Callable` returns, the request is dispatched back to the
  Servlet container to resume processing using the value returned by the `Callable`. Here
  is an example of such a controller method:
  
  [source,java,indent=0]
  [subs="verbatim,quotes"]
  