Wie soll ich AsynchronousServerSocketChannel für die Annahme von verbindungen?

Möchte ich schreiben, eine asynchrone server mit Java 7 und NIO 2.

Aber wie soll ich AsynchronousServerSocketChannel?

E. g. wenn ich starte mit:

final AsynchronousServerSocketChannel server = 
    AsynchronousServerSocketChannel.open().bind(
        new InetSocketAddress(port));

Dann, wenn ich server.accept() das Programm beendet da dieser Aufruf ist asynchrone. Und wenn ich den code in einer Endlosschleife, ein AcceptPendingException geworfen wird.

Irgendwelche Vorschläge auf, wie man eine einfache asynchrone server mit AsynchronousServerSocketChannel?

Hier mein vollständiges Beispiel (ähnlich wie das Beispiel in der JavaDoc):

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AsyncServer {

    public static void main(String[] args) {
        int port = 8060;
        try {
            final AsynchronousServerSocketChannel server = 
                    AsynchronousServerSocketChannel.open().bind(
                            new InetSocketAddress(port));

            System.out.println("Server listening on " + port);

            server.accept("Client connection", 
                    new CompletionHandler<AsynchronousSocketChannel, Object>() {
                public void completed(AsynchronousSocketChannel ch, Object att) {
                    System.out.println("Accepted a connection");

                    //accept the next connection
                    server.accept("Client connection", this);

                    //handle this connection
                    //TODO handle(ch);
                }

                public void failed(Throwable exc, Object att) {
                    System.out.println("Failed to accept connection");
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Sie können Netty-framework, das speziell für client-server-Anwendung. Es verwendet auch java NIO. Es ist eine einfache und schnelle Entwicklung von server. gehen Sie über netty.io
Ich weiß, über netty, das ist aber nicht relevant für diese Frage.

InformationsquelleAutor Jonas | 2012-01-20

12

Sind Sie auf der richtigen Spur, Aufruf von accept() aus dem abgeschlossenen Rückruf, um zu akzeptieren, mehr verbindungen funktionieren sollte.

Einer einfachen (aber hässlich) Weg zu verhindern, dass den thread zu beenden ist einfach eine Schleife, bis der thread unterbrochen wird.
```
//yes, sleep() is evil, but sometimes I don't care
while (true) {
    Thread.sleep(1000);
}
```
Sauberer ist die Verwendung AsynchronousChannelGroup. Zum Beispiel:
```
AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(Executors
            .newSingleThreadExecutor());
AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group).bind(
            new InetSocketAddress(port));

//(insert server.accept() logic here)

//wait until group.shutdown()/shutdownNow(), or the thread is interrupted:
group.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
```
Können Sie abstimmen, wie threads verarbeitet werden, finden Sie in der AsynchronousChannelGroup API-docs für weitere Informationen.
- // yes, sleep() is evil, but sometimes I don't care Sie kümmern sollte.
- Heh. Immer downvotes auf diese, vermutlich wegen der sleep () - Aufruf, obwohl ich nannte es ugly und böse, und dann zeigen, ein schöner Weg. Das scheint ziemlich dogmatisch. 🙂
InformationsquelleAutor Soulman
4

Asynchrone akzeptieren ist nützlich, wenn Sie etwas anderes zu tun in dem gleichen thread. In den Fall, Sie nicht etwas anderes tun, so würde ich
```
while(true) {
    AsynchronousSocketChannel socket = server.accept().get();
    System.out.println("Accepted " + socket);
    socket.close();
}
```
- Zukunft.get() wartet...
- Tut es, aber accept() gibt eine andere Zukunft zu jeder Zeit.
- Mein Punkt ist dein Beispiel ist eine Blockierung server, die Niederlagen der Zweck von AsynchronousServerSocketChannel.
- Nur die Annahme der thread blockiert. Wenn Sie einen handler-thread für den Umgang mit sockets, dies ist nicht ein Problem.
- Sie sollten nicht mehrere threads in einem asynchronen server, das ist das schöne daran, das OS behandelt alles intern und es benachrichtigt Sie, wenn IO getan werden muss, deshalb sollten Sie nie auf einen thread zu warten, für Sie. Verwenden Sie ein CompletionHandler und es automatisch überwacht verbindungen zu akzeptieren.
- Außer natürlich, dass Java verwendet einen ExecutorService zur Durchführung der lese - /Schreibzugriff und die Rückkehr der Zukunft. Es verwendet nicht den OS-durchführen von asynchronen Operationen als solche (außer vielleicht für inifini-band). 😉
- Das ist der Unterschied zwischen AsynchronousServerSocketChannel und ServerSocketChannel?
- Es gibt mehrere Implementierungen. Der Standardwert verwendet ExecutorService, aber ich kann mir vorstellen das Infini-band-Unterstützung bedeutet, dass es hat seine eigene Implementierung, aber ich habe nicht verwendet diese.
InformationsquelleAutor Peter Lawrey
1

Andere alternative ist es, Ihre main-Methode wartet auf ein signal, bevor er zurückkehrt. Dann wenn Sie irgendeine Art von externen Befehl shutdown, den Sie nur Benachrichtigen Sie das signal-und der main-thread beendet.
```
private static final Object shutdownSignal = new Object();

public static void main(String[] args) {

    ...

    synchronized (shutdownSignal) {
        try {
            shutdownSignal.wait();
        }
        catch (InterruptedException e) {
            //handle it!
        }
    }
}
```
- Würde ich nicht verwenden, "Objekt" als Kennung entweder ein boolescher aber nicht genau die boolean-Klasse, weil Sie es bricht so dass Sie mit seltsamen Nebenwirkungen (Lesen Quelle warum) Beste Lösungen: ~ Synchronisieren auf eine private final Object, speziell die für den Zweck (ordentlicher, wenn jemand anderes erweitern unsere Klasse) ~ Ersetzen shutdownSignal mit einem letzten AtomicBoolean, den Sie verändern können mithilfe von get-und set-Methoden statt Zuweisungen (wirst du noch brauchen, um zu synchronisieren, die für die Prüfung der Staat) Quelle: telliott.io/node/40 ( warum nicht verwenden boolean on synchronized)
- Dein Kommentar macht keinen Sinn. Das ist genau der Anwendungsfall für wait/notify. Es gibt keine seltsamen Nebenwirkungen möglich, wie beschrieben in der Quell-Artikel, da gibt es keine Zuweisung Auftritt hier. Dies ist nur ein körpereigener Mechanismus.
InformationsquelleAutor dOxxx

Verwenden Sie count-down-Verriegelung, wie im folgenden Beispiel

    final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
    InetSocketAddress address = new InetSocketAddress(port);
    serverChannel.bind(address);
    final CountDownLatch latch = new CountDownLatch(1);
    serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
@Override
        public void completed(final AsynchronousSocketChannel channel, Object attachment) {
            serverChannel.accept(null, this);
                        }

});
try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }

InformationsquelleAutor Deepak Srinivasan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.