Java réseau: evented Socket/InputStream

Peu non. available() n'est pas fiable (au moins, il n'était pas pour moi). Je recommande d'utiliser java.nio.channels.SocketChannel connecté avec Selector et SelectionKey. Cette solution est un peu l'événement, mais c'est plus compliqué que de simples supports.

Pour les clients:

1. Construire socket canal (socket), ouvrir un sélecteur (selector = Selector.open();).
2. Utilisation non-bloquant socket.configureBlocking(false);
3. Registre sélecteur pour les connexions socket.register(selector, SelectionKey.OP_CONNECT);
4. Connecter socket.connect(new InetSocketAddress(host, port));
5. Voir si il n'y a rien de nouveau selector.select();
6. Si le "nouveau" se réfère à la connexion réussie, vous inscrire sur le sélecteur pour OP_READ; si le "nouveau" se réfère aux données disponibles, il suffit de lire à partir de la douille.

Cependant, afin d'avoir asynchrone, vous devez configurer un thread séparé (en dépit de la prise en cours de création en tant que non-bloqué, le thread va bloquer toute façon) qui vérifie si quelque chose est arrivé ou pas.

Pour les serveurs, il n'y a ServerSocketChannel et que vous utilisez OP_ACCEPT pour elle.

Pour la référence, c'est mon code (client), devrait vous donner un indice:

 private Thread readingThread = new ListeningThread();
/**
* Listening thread - reads messages in a separate thread so the application does not get blocked.
*/
private class ListeningThread extends Thread {
public void run() {
running = true;
try {
while(!close) listen();
messenger.close();
}
catch(ConnectException ce) {
doNotifyConnectionFailed(ce);
}
catch(Exception e) {
//   e.printStackTrace();
messenger.close();
}
running = false;
}
}
/**
* Connects to host and port.
* @param host Host to connect to.
* @param port Port of the host machine to connect to.
*/
public void connect(String host, int port) {
try {
SocketChannel socket = SocketChannel.open();
socket.configureBlocking(false);
socket.register(this.selector, SelectionKey.OP_CONNECT);
socket.connect(new InetSocketAddress(host, port));
}
catch(IOException e) {
this.doNotifyConnectionFailed(e);
}
}
/**
* Waits for an event to happen, processes it and then returns.
* @throws IOException when something goes wrong.
*/
protected void listen() throws IOException {
//see if there are any new things going on
this.selector.select();
//process events
Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
while(iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
//check validity
if(key.isValid()) {
//if connectable...
if(key.isConnectable()) {
//...establish connection, make messenger, and notify everyone
SocketChannel client = (SocketChannel)key.channel();
//now this is tricky, registering for OP_READ earlier causes the selector not to wait for incoming bytes, which results in 100% cpu usage very, very fast
if(client!=null && client.finishConnect()) {
client.register(this.selector, SelectionKey.OP_READ);
}
}
//if readable, tell messenger to read bytes
else if(key.isReadable() && (SocketChannel)key.channel()==this.messenger.getSocket()) {
//read message here
}
}
}
}
/**
* Starts the client.
*/
public void start() {
//start a reading thread
if(!this.running) {
this.readingThread = new ListeningThread();
this.readingThread.start();
}
}
/**
* Tells the client to close at nearest possible moment.
*/
public void close() {
this.close = true;
}

Et pour le serveur:

 /**
* Constructs a server.
* @param port Port to listen to.
* @param protocol Protocol of messages.
* @throws IOException when something goes wrong.
*/
public ChannelMessageServer(int port) throws IOException {
this.server = ServerSocketChannel.open();
this.server.configureBlocking(false);
this.server.socket().bind(new InetSocketAddress(port));
this.server.register(this.selector, SelectionKey.OP_ACCEPT);
}
/**
* Waits for event, then exits.
* @throws IOException when something goes wrong.
*/
protected void listen() throws IOException {
//see if there are any new things going on
this.selector.select();
//process events
Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
while(iter.hasNext()) {
SelectionKey key = iter.next();
//do something with the connected socket
iter.remove();
if(key.isValid()) this.process(key);
}
}
/**
* Processes a selection key.
* @param key SelectionKey.
* @throws IOException when something is wrong.
*/
protected void process(SelectionKey key) throws IOException {
//if incoming connection
if(key.isAcceptable()) {
//get client
SocketChannel client = (((ServerSocketChannel)key.channel()).accept());
try {
client.configureBlocking(false);
client.register(this.selector, SelectionKey.OP_READ);
}
catch(Exception e) {
//catch
}
}
//if readable, tell messenger to read
else if(key.isReadable()) {
//read
}
}

Espère que cette aide.