# HTTP ServerThread



## Roland34 (16. Jun 2008)

2.Post weil ich es in falscher Stelle gepostet hatte.


Hat jemand eine Idee über Thread Handling in Java http server?
Ich habe die HTTP server wie unten implementiert. Ich möchte bei jeder Client Verbindung (wie z.B. Aktualisierung der Web Seite) eine Datanbankabfrage laufen und die Werte im Bildschirm ausgeben. Funktioniert soweit.

String response = QueryManager.runQuery();

Aber mein Problem ist dass bei jedem Client Zugriff wird ein neues Thread erzeugt. Das möchte ich vermeiden, wegen Speicherüberlauf.
Aber wenn ich das Response als statische Variabel definiere, passiert das nicht. wie z.B. String response = "test"; 


```
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.Calendar;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

public class MyHTTPServer implements HttpHandler {

  HttpServer server;

  String myname;


  String mydesc;

  int port = 8080;

  class MyHandler implements HttpHandler {
    public void handle(HttpExchange t) throws IOException {
      String response  = QueryManager.runQuery();
      if (response.length() == 0) {
        response = "0";
      }
      // System.out.println(response);
      t.sendResponseHeaders(200, response.length());
      OutputStream os = t.getResponseBody();
      os.write(response.getBytes());
      os.close();
    }
  }

  public MyHTTPServer() throws IOException {
    HttpServer server = HttpServer.create(new InetSocketAddress(port), 100);
    server.createContext("/", new MyHandler());
    server.setExecutor(null);
    server.start();

  }

  public void read(InputStream is) {
  }

  public static void main(String argv[]) {
    try {
      new MyHTTPServer(); // start the result server
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public void handle(HttpExchange arg0) throws IOException {
   
   
  }

}
```


----------



## tuxedo (16. Jun 2008)

Du suchst das hier: http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/ExecutorService.html

Damit kannst du ganz easy "Runnables" in einen ThreadPool werfen, worin sie ausgeführt werden, ohne bei 2000 Anfragen 2000 Threads zu benötigen und ohne einen Speicherüberlauf zu bekommen.

- Alex


----------



## Roland34 (16. Jun 2008)

Danke Alex.
Bin etwas neu zum Socket Konzept in java.  Habe versucht es mit dem Beispiel aber mir scheint es etwas komplexer. 

Was mir brennend interessiert ist, warum wird mehrere Threads für 

```
String response = QueryManager.runQuery();
```
 erzeugt?
Aber nicht bei 


```
String response  = "response";
```

Vielleicht verpasse ich ein ganz einfaches Konzept!


----------



## tuxedo (16. Jun 2008)

Kein Plan was du da treibst... Prinzipiell müsste das bei dir so funktionieren:

Für jede eingehende Anfrage wird ein Objekt erzeugt, welches "Runnable" implementiert. In dessen "run()" Methode arbeitest du die Anfrage ab und gibst das Ergebnis zurück.

Zentral in deiner Webserveranwendung erstellst du einen Thread-Pool, z.B. so:


```
ExecutorService threadPool = Executors.newFixedThreadPool(20);
```

Und die Runnables steckst du dann so rein:


```
threadPool.execute(meinAnfrageRunnableObject);
```

Der Pool kümmert sich dann um dessen Ausführung und entscheidet wann welche Anfrage dran kommt. 

"Executors" kennt noch weitere statische Methoden zum Pool erzeugen:

- Executors#newCachedThreadPool()
- Executors#newSingleThreadExecutor()
- Executors#newFixedThreadPool(int size)

Gruß
Alex


----------



## Roland34 (17. Jun 2008)

Danke Alex,

Hat mir auch viel geholfen um  meine Kenntnisse zu erweitern und das Problem zulösen.


----------

