# Jetty 9 Non Blocking Handler Frage...



## C3lt1c (1. Jan 2017)

Hi,
Ich habe mir mal die Jetty Lib angeschaut und bin begeistert von ihr 
Meine Frage ist nun wie ich es hinbekomme das mehrere Request zu dem Jetty WebServer hingesendet werden können die dann paralell bearbeitet werden. Ich habe es mit QueuedThreadPool ausprobiert doch bin zu keiner Lösung gekommen. Ich habe in den RequestHandler extra ein kleines Sleep eingebaut um so reine Response zu verzögern. Doch wenn ich den Server dann von 2 WebBrowsern ansteuer, wird das ganze wieder wie ein Query gehändelt. Erst wenn der eine seine Response gesendet hat wird die andere Anfrage bearbeitet.

Hier meinen SourceCode zu dem Demo Projekt:

>>>MAIN.java<<<


```
public class WebServer {

    static boolean mainLoopActive = true;
   
    //----------------------------------------------------------
   
    private static void print(final String text) {
       
        System.out.println("[MAIN]>>\t" + text);
       
    }
   
    //----------------------------------------------------------
   
    public static void main(String[] args) {
       
        print("start...");
       
        //+++++++++++++++++++++++++++++++++++++
       
        WebServerModule.getInstance();
        WebServerModule.getInstance().startServer();
       
   
       
       
        //+++++++++++++++++++++++++++++++++++++
       
        print ("start main loop");
       
        while(mainLoopActive){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {}
        }
       
        print("exit...");

    }
   
    //----------------------------------------------------------

}
```

>>>WebServerModule.java<<<


```
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.eclipse.jetty.util.thread.QueuedThreadPool;

public class WebServerModule {

    private static WebServerModule _instance = null;
    private Server server;
    QueuedThreadPool threadPool;

    private final int port = 8081;
    private int requestCounter = 0;

    // ---------------------------------------------------------
    public static WebServerModule getInstance() {

        if (_instance == null) {
            _instance = new WebServerModule();
        }

        return _instance;

    }

    // ---------------------------------------------------------

    private WebServerModule() {
        print("created...");
        init();
    }

    // ---------------------------------------------------------

    private void print(final String text) {

        System.out.println(
                new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "\t[WebServerModule]>>\t" + text);

    }
    // ---------------------------------------------------------

    private void init() {
        print("init...");
        threadPool = new QueuedThreadPool();
        threadPool.setMaxThreads(5);
        threadPool.setMinThreads(5);
       
        ServerConnector serverConnector;
        server = new Server(threadPool);
        serverConnector = new ServerConnector(server);
        serverConnector.setPort(8081);
        server.addConnector(serverConnector);
        server.setHandler(new WebHandler());
        try {
            threadPool.start();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    // ---------------------------------------------------------

    public void startServer() {

        print("start server...");
        try {
            server.start();
            server.join();

        } catch (Exception e) {
            print("error...");
            e.printStackTrace();
        }

    }

    // ---------------------------------------------------------

    public void stopServer() {

        print("start server...");
        try {
            server.stop();
        } catch (Exception e) {
            print("error...");
            e.printStackTrace();
        }

    }

    // ---------------------------------------------------------

    public class WebHandler extends AbstractHandler {

        @Override
        public void handle(String str, Request request, HttpServletRequest httpRequest,
                HttpServletResponse httpResponse) throws IOException, ServletException {

            request.setHandled(true);

            requestCounter++;
            print("request event " + requestCounter + "...");

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e1) {
            }

            httpResponse.setContentType("text/html;charset=utf-8");
            httpResponse.setStatus(HttpServletResponse.SC_OK);
            try {
                httpResponse.getWriter().println("<h1>Request " + requestCounter + " Ok...</h1>");
            } catch (IOException e) {
                print("error...");
            }

        }

    }

    // ---------------------------------------------------------
}
```


----------



## JuKu (2. Jan 2017)

Jetty nutzt vermutlich einen Thread Pool, d.h. mit einem sleep blockierst du einen ganzen Thread.
Und ich denke, dass Jetty sehr wohl die Abfragen parallel abarbeiten kann.


----------

