Effizienz der while(true) ServerSocket Hören

Frage ich mich, ob eine typische while(true) ServerSocket hören Schleife nimmt einen ganzen Kern, zu warten und zu akzeptieren, eine client-Verbindung (Auch bei der Implementierung von runnable und Verwendung Thread .start())

Ich die Umsetzung eine Art von distributed computing cluster und jeder computer braucht jeder Kern hat es für die Berechnung. Ein Master-Knoten benötigt für die Kommunikation mit diesen Rechnern (Aufruf von statischen Methoden, das ändern des Algorithmus funktionieren).

Der Grund, warum ich brauchen, um sockets verwenden, ist aufgrund der cross-Plattform /cross-language-Fähigkeiten. In einigen Fällen wird PHP Aufruf dieser java statische Methoden.

Habe ich eine java-profiler (YourKit) und ich kann sehen, meine läuft ServerSocket listen-thread und es schläft nie und es ist immer mit. Gibt es eine bessere Methode das zu tun, was ich will? Oder wird die Leistung Treffer vernachlässigbar sein?

Bitte fühlen Sie sich frei zu bieten jede Anregung, wenn Sie sich vorstellen können, einen besseren Weg (ich habe versucht, RMI, aber es wird nicht unterstützt cross-Sprache.

Danke an alle

Damit sollte nicht passieren, wenn Sie ‘akzeptieren‘. Kannst du etwas code?
erickson war genau auf den Punkt mit dem code, den er geschrieben while (true) { Socket socket = server.accept(); /* Tu was mit sockel... */ }
Wie viele verbindungen/Sekunde sind Sie die Handhabung?
Jetzt, nicht viele. Jedoch, das könnte leicht in ein Dutzend oder so. Die Informationen, die übertragen wird, ist sehr klein, so sollte es nicht sein, viele gleichzeitige aktive sockets

InformationsquelleAutor Submerged | 2010-05-17

8

Wenn du meinst so etwas wie dieses:
```
while (true) {
  Socket socket = server.accept();
  /* Do something with socket... */
}
```
dann, Nein, den Anruf zu accept() nicht "nehmen Sie einen ganzen Kern." Es ist ein blockierender Aufruf, dass die CPU eingeplant werden für einen anderen thread, bis sich ein client verbindet. Wenn der Ruf zum accept() gibt, ist der aktuelle thread ausgeführt werden soll, und die CPU bis er blockiert auf accept() in der nächsten iteration der Schleife.

Zu vermeiden, die Zuhören Rückstand der anderen Kunden, es zu umfangreich wird, ein anderer thread in der Regel übernimmt die Interaktion mit dem neu-akzeptiert Socket, so dass ein thread, um den Fokus auf die Annahme neuer Kunden. Die socket-Handhabung thread vielleicht handhaben Sie viele sockets, Verwendung von NIO oder könnte es sein, der sich in einer single-socket -, die viel einfacher ist code, der aber nicht gut skalieren Vergangenheit viele Hunderte von gleichzeitigen verbindungen.

InformationsquelleAutor erickson

Möchten Sie vielleicht einen Blick auf die Java 1.4 nio-Bibliotheken und insbesondere ServerSocketChannel. Ich nutze dieses sehr erfolgreich zu implementieren, die eine effiziente server, die Schlüssel-bits code:

Selector selector = Selector.open();

ServerSocketChannel server= ServerSocketChannel.open();
server.socket().bind(new java.net.InetSocketAddress(port));
server.configureBlocking(false);
SelectionKey serverKey = server.register(selector, SelectionKey.OP_ACCEPT);

//start listening thread
new Thread(listener).start();

Und der Hörer ist nur eine Schleife, die läuft:

selector.select(1000); //listen for one second max
Set<SelectionKey> keys = selector.selectedKeys();

if (keys.size()>0) {
    handleKeys(keys);
}

Ich war auf der Suche in die Buchse Kanäle, vielen Dank für dieses posting!

InformationsquelleAutor mikera

3

Habe ich eine java-profiler (YourKit) und ich kann sehen, meine läuft ServerSocket listen-thread und es schläft nie und es ist immer mit.

Grundsätzlich der profiler ist irreführend Sie.

Ich davon aus, dass Ihr code wie folgt aussieht:
```
ServerSocket server = ...
//configure server socket

try {
    while (true) {
        Socket socket = server.accept();
        //do something with socket (and close it afterwards!)
    }
} catch (InterruptedException ex) {
    //we're outta here!
}
```
Diese nicht verbrauchen signifikante CPU ... es sei denn, Sie haben etwas getan, pathologischen, wie der Aufruf ServerSocket.setSoTimeout(int) mit einem kleinen timeout.

InformationsquelleAutor Stephen C
0

Lassen den Kern ein wenig schlafen. In Ihr Ablaufenden Methode, fügen Sie so etwas wie
```
Thread.sleep(250); //milliseconds 
```
in jeder Schleife.

Sollten deutlich reduzieren die CPU-Auslastung

Edit: schlechte Idee, siehe Kommentare, sorry, mein Fehler

Und: verwenden Sie nicht while(true). es ist schrecklich design, wie die Semantik suggerieren, die schließlich wahr werden nicht mehr wahr. In der Regel werden Sie wollen, um die Abfrage einige flüchtige oder Atomare variable aus der main-thread
```
public class MyClass {

class MyRunnable implements Runnable {

    public void run() {
        while (MyClass.this.keepGoing.get()) {
            //listen();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                //deal with exception
            }

        }
    }

}

private final AtomicBoolean keepGoing = new AtomicBoolean(true);

}
```
Diese Weise kann der Haupt-thread hat einen Weg, um den listener zu beenden thread.
- Ich bin nicht sicher, dies ist eine großartige Idee, wie es wird limit Ihrer verbindungen.
- yup, habe ich falsch verstanden, die Frage. Ich dachte, es war nur ein thread, der wartete für einen Dienst zu starten, aber für einen Socket-listener, der hört tatsächlich auf user-Wünsche, das ist schlecht beraten.
- hi , in welchem Zusammenhang Sie gemeint, "das wahre nicht mehr wahr" ?
- Ich meine: was du sagst, ist "zwar wahr ist, ist wahr, keep going'. Allerdings, wenn Sie eine Pause oder throw oder return-Anweisung an beliebiger Stelle in der Schleife, dabei sind Sie darauf hindeutet, dass das wahre nicht mehr wahr, und das ist semantisch ungeschickt, obwohl technisch ok.
- IMO beste Ansatz ist, um die while (true) inside der try-block mit der catch für InterruptedException.
InformationsquelleAutor Sean Patrick Floyd

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.