public class SimpleAsyncServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        AsyncContext asyncContext = req.startAsync(req, resp);
        Listener listener = new Listener(asyncContext);
        req.getInputStream().setReadListener(listener);
        resp.getOutputStream().setWriteListener(listener);
    }

    private class Listener implements ReadListener, WriteListener, AsyncListener {
        private final AsyncContext asyncContext;
        private final ServletInputStream inputStream;
        private final ServletOutputStream outputStream;

        public Listener(AsyncContext asyncContext) throws IOException {
            this.asyncContext = asyncContext;
            this.inputStream = asyncContext.getRequest().getInputStream();
            this.outputStream = asyncContext.getResponse().getOutputStream();
        }

        @Override
        public void onDataAvailable() throws IOException {
            // читаем данные из inputStream 
        }

        @Override
        public void onAllDataRead() throws IOException {
            // выполняем какие действия с данными, может выполняться долго
        }

        @Override
        public void onWritePossible() throws IOException {
            // пишем данные в outputStream 
            asyncContext.complete();
        }

        @Override
        public void onError(Throwable t) {
            // логируем ошибку
        }
    }
}

$.ajaxSetup({timeout:500});

chain.doFilter(

this.Destroy()

@WebServlet("/MyAsyncTestServlet" asyncSupported=true)
  public class TestServlet extends HttpServlet {
    public void doGet(HttpServletRequest req, HttpServletResponse res) {
      ...
      AsyncContext aCtx = request.startAsync(req, res);
      ScheduledThreadPoolExecutor executor = new ThreadPoolExecutor(10);
      executor.execute(new MyAsyncService(aCtx));
    }
  }

void doPost(Request req, Response resp) {    
    AtomicReference resultHolder = new AtomicReference();
    AtomicBoolean canceled = new AtomicBoolean();
    ScheduledFuture sf = scheduler.schedule(() -> {
          if(resultHolder.get() == null){
                canceled.set(true);
                respondWithTimeout(req, resp);
          }   
    }, 500, MILLISECONDS);
    Result result =  runProcessing(req, canceled);
    sf.cancel(false);
    if(!canceled.get()){
        resultHolder.set(result);
        respond(result);
    }
}