Puis-je faire une Java HttpServer fileté/traiter les demandes en parallèle?

J'ai construit un simple serveur http suivant les tutoriels que j'ai trouvé en ligne, avec du Soleil léger HttpServer.

Fondamentalement, la fonction principale ressemble à ceci:

public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        //Create the context for the server.
        server.createContext("/", new BaseHandler());

        server.setExecutor(null); //creates a default executor
        server.start();
    }

Et j'ai mis en œuvre la BaseHandler Interface de la méthode pour traiter la requête Http et de renvoyer une réponse.

static class BaseHandler implements HttpHandler {
        //Handler method
        public void handle(HttpExchange t) throws IOException {

          //Implementation of http request processing
          //Read the request, get the parameters and print them
          //in the console, then build a response and send it back.
        }
  }

J'ai également créé un Client qui envoie plusieurs requêtes via les threads. Chaque thread envoie la demande au serveur:

http://localhost:8000/[contexte]?int="+threadID

Sur Chaque client d'exécuter, à La demande semble arriver dans un ordre différent pour le serveur, mais ils sont servis dans une série.

Ce que je souhaite réaliser est pour les demandes soient traitées de la même manière, si cela est possible.

Est-il possible, par exemple, pour exécuter chaque gestionnaire dans un autre thread, et si oui, est-ce une bonne chose à faire.

Ou devrais-je déposer à l'aide du Soleil léger serveur et la mise au point d'une construction de quelque chose à partir de zéro?

Merci pour toute aide.

C'est ce que le serveur http le fait déjà.
Ceci est fait en mettant l'exécuteur testamentaire, voir docs.oracle.com/javase/6/docs/api/java/util/concurrent/...
Si c'est rien, mais un projet d'apprentissage, je vous recommande de regarder les bibliothèques comme Apache Mina ou Netty.
Merci pour les réponses rapides à tous! Je vais regarder plus en plus vite.

OriginalL'auteur Humunculus84 | 2013-02-06

  1. 18

    Comme vous pouvez le voir dans ServerImpl, l'exécuteur par défaut juste "exécuter" la tâche :

      157       private static class DefaultExecutor implements Executor {
  158           public void execute (Runnable task) {
  159               task.run();
  160           }
  161       }

    vous devez fournir un véritable exécuteur testamentaire pour votre serveur http, comme ça :

    server.setExecutor(java.util.concurrent.Executors.newCachedThreadPool());

    et que votre serveur va s'exécuter en parallèle.
    Attention, ceci est un non-limitée Exécuteur testamentaire, voir Les exécuteurs.newFixedThreadPool de limiter le nombre de Thread.

    Merci pour la réponse rapide. Je vais regarder plus en exécuteurs testamentaires et voir si je comprends mieux 🙂
    Petite question cependant: l'exécuteur de remplacer le gestionnaire de maintenant, dans un sens ou est quelque chose de différent?
    non, le seul moyen de "servir" de la tâche. Avec un newCahdedThreadPool(), il va créer autant de fil à la demande. Mais votre gestionnaire sera appelé comme d'habitude. Prenez soin de vous, si vous réutilisez le même gestionnaire, il doit être thread-safe.
    Regarde comme il fonctionne très bien avec newFixedThreadPool, mais j'ai besoin de plus d'études sur les exécuteurs. Merci beaucoup pour la réponse!
    le serveur est synchrone : il écoute sur le port, accepter la prise de courant et démarrer un nouveau thread

    OriginalL'auteur twillouer

  2. 0

    Vous avez utilisé le serveur.setExecutor(null) qui exécute le gestionnaire dans le même thread appelant. Dans ce cas, le thread principal qui exécute le serveur.

    Il vous suffit de modifier la ligne comme 

    public static void main(String[] args) throws Exception {

    HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
    //Create the context for the server.
    server.createContext("/", new BaseHandler());
    server.setExecutor(Executors.newCachedThreadPool());
    server.start();
}

    OriginalL'auteur user3322581