Comment puis-je vous interrompre un ServerSocket méthode accept ()?

Set timeout sur accept(), l'appel expire le blocage après un certain temps:

http://docs.oracle.com/javase/7/docs/api/java/net/SocketOptions.html#SO_TIMEOUT

Définir un délai d'attente sur le blocage des Socket opérations:

ServerSocket.accept();
SocketInputStream.read();
DatagramSocket.receive();

L'option doit être définie avant d'entrer dans une opération de blocage de prendre effet. Si le délai expire et que l'opération serait de continuer à bloquer, java.io.InterruptedIOException est soulevée. Le Socket n'est pas fermé dans ce cas.

Il vous suffit de créer "void" prise pour briser serversocket.accept()

Côté serveur

private static final byte END_WAITING = 66;
private static final byte CONNECT_REQUEST = 1;

while (true) {
      Socket clientSock = serverSocket.accept();
      int code = clientSock.getInputStream().read();
      if (code == END_WAITING
           /*&& clientSock.getInetAddress().getHostAddress().equals(myIp)*/) {
             //End waiting clients code detected
             break;
       } else if (code == CONNECT_REQUEST) { //other action
           //...
       }
  }

Méthode pour casser serveur cycle

void acceptClients() {
     try {
          Socket s = new Socket(myIp, PORT);
          s.getOutputStream().write(END_WAITING);
          s.getOutputStream().flush();
          s.close();
     } catch (IOException e) {
     }
}

Utilisation serverSocket.setSoTimeout(timeoutInMillis).

OK, j'ai eu ce travail d'une manière que les adresses de l'OP est question plus directement.

Garder la lecture passé, la réponse la plus courte pour un Thread exemple de la façon dont je l'utilise.

Réponse courte:

ServerSocket myServer;
Socket clientSocket;

  try {    
      myServer = new ServerSocket(port)
      myServer.setSoTimeout(2000); 
      //YOU MUST DO THIS ANYTIME TO ASSIGN new ServerSocket() to myServer‼!
      clientSocket = myServer.accept();
      //In this case, after 2 seconds the below interruption will be thrown
  }

  catch (java.io.InterruptedIOException e) {
      /*  This is where you handle the timeout. THIS WILL NOT stop
      the running of your code unless you issue a break; so you
      can do whatever you need to do here to handle whatever you
      want to happen when the timeout occurs.
      */
}

Monde réel exemple:

Dans cet exemple, j'ai un ServerSocket d'attente pour une connexion à l'intérieur du Fil. Lorsque je ferme l'appli, je veux arrêter le thread (plus précisément, la prise) d'une façon propre avant de me laisser l'application fermer, donc j'utilise la .setSoTimeout() sur le ServerSocket puis-je utiliser l'interruption est levée après le délai d'attente pour vérifier et voir si le parent est en train d'essayer d'arrêter le fil. Si oui, puis j'ai mis de fermer le socket, puis définir un indicateur qui indique que le thread est fait, puis-je sortir d'entre les Fils de la boucle qui renvoie une valeur null.

package MyServer;
import javafx.concurrent.Task;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import javafx.concurrent.Task;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
public class Server {
public Server (int port) {this.port = port;}
private boolean      threadDone        = false;
private boolean      threadInterrupted = false;
private boolean      threadRunning     = false;
private ServerSocket myServer          = null;
private Socket       clientSocket      = null;
private Thread       serverThread      = null;;
private int          port;
private static final int SO_TIMEOUT    = 5000; //5 seconds
public void startServer() {
if (!threadRunning) {
serverThread = new Thread(thisServerTask);
serverThread.setDaemon(true);
serverThread.start();
}
}
public void stopServer() {
if (threadRunning) {
threadInterrupted = true;
while (!threadDone) {
//We are just waiting for the timeout to exception happen
}
if (threadDone) {threadRunning = false;}
}
}
public boolean isRunning() {return threadRunning;}
private Task<Void> thisServerTask = new Task <Void>() {
@Override public Void call() throws InterruptedException {
threadRunning = true;
try {
myServer = new ServerSocket(port);
myServer.setSoTimeout(SO_TIMEOUT);
clientSocket = new Socket();
} catch (IOException e) {
e.printStackTrace();
}
while(true) {
try {
clientSocket = myServer.accept();
}
catch (java.io.InterruptedIOException e) {
if (threadInterrupted) {
try { clientSocket.close(); } //This is the clean exit I'm after.
catch (IOException e1) { e1.printStackTrace(); }
threadDone = true;
break;
}
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
};
}

Puis, dans ma classe de Contrôleur ... (je ne montre que le code pertinent, de massage dans votre propre code en fonction des besoins)

public class Controller {
Server server = null;
private static final int port = 10000;
private void stopTheServer() {
server.stopServer();
while (server.isRunning() {
//We just wait for the server service to stop.
}
}
@FXML private void initialize() {
Platform.runLater(()-> {
server = new Server(port);
server.startServer();
Stage stage = (Stage) serverStatusLabel.getScene().getWindow();
stage.setOnCloseRequest(event->stopTheServer());
});
}
}

J'espère que cela aide quelqu'un en bas de la route.