Question

我想在执行成功的传入套接字连接时执行返回套接字的服务器线程，并且很容易关闭......简单而干净。

ServerSocketThread.java：

创建侦听端口

的ServerSocket

返回Socket传入的客户端连接

public class ServerSocketThread implements Callable<Socket> {

    private ServerSocket serverSocket;
    private Integer listeningPort;

    public SocketListener(Integer listeningPort) {
        this.listeningPort = listeningPort;
    }

    @Override
    public Socket call() throws Exception {
        serverSocket = new ServerSocket(listeningPort);
        return serverSocket.accept();
    }

    public interrupt() throws IOException {
        serverSocket.close();
    }

}

但是，我执行这些线程的当前实现是：

ServerSocketExecutor.java：

创建ServerSocketListener线程

从ServerSocketListener线程观察传入套接字

为其Mediator生成传入套接字

public class ServerSocketExecutor extends Producer<Socket> implements Observer {

    List<Integer> listeningPorts = Collections.emptyList();

    public ServerSocketExecutor(List<Integer> listeningPorts) {
        this.listeningPorts = listeningPorts;
    }

    public Void call() throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(listeningPorts.size());
        List<ServerSocketListener> socketListeners = new ArrayList<ServerSocketListener>();

        // Instantiate new ServerSocketListener for each listeningPort
        for (Integer port : listeningPorts) {
            socketListeners.add(new ServerSocketListener(this).listenOnPort(port));
        }

        try {
            executor.invokeAll(socketListeners);
        } catch (InterruptedException e) {

        }
        return null;
    }

    public synchronized void update(Observable o, Object socket) {
        produce((Socket) socket); // Produces to Mediator<Socket>
    }
}

我的ServerSocketListener.java是：

ServerSocketListener.java：

侦听给定端口上的传入连接

通知观察者Socket连接

继续侦听传入连接

public class ServerSocketListener extends Observable implements Callable<Void> {

    ServerSocket server;
    private Integer listeningPort;
    Boolean runnable = true;

    public ServerSocketListener(Observer o) {
        addObserver(o);
    }

    public ServerSocketListener listenOnPort(Integer listeningPort) {
        this.listeningPort = listeningPort;
        return this;
    }

    public Void call() throws Exception {
        server = new ServerSocket(listeningPort, 10);

        while (runnable) {
            Socket socket = server.accept();

            setChanged();
            notifyObservers(socket);
        }
        return null;
    }

    public void interrupt() throws IOException {
        runnable = false;
        server.close();
    }
}

我坚持这对线程应该具备的一些基本行为。

我不确定List＆lt; Future＆lt; Void＆gt;＆gt;可以在我的ServerSocketExecutor中提供给我。可以未来＆lt; Void＆gt;解决了线程终止的一些问题？

如何彻底终止这些线程？ ServerSocketListener忽略executor.shutdown（）和future.get（）块。终止ServerSocketThread类很容易，终止阻塞似乎非常困难的东西。

我看到有人说要使用：

Thread.currentThread().interrupt();

但是我不确定如何调用它，如果它会对这些线程产生负面影响，或者我需要捕获哪些异常以及在哪里。

最后但并非最不重要的是，如何在返回未来后重新运行ServerSocketThread？ ServerSocketExecutor需要在关闭后重新生成ServerSocket线程。另一种方法是在循环中运行它们......但这导致我当前的实现，这使我回到原点。

我知道这很多，但我现在所能做的就是像金鱼一样盯着这个代码，我需要在后面踢一下。

可调用的未来，如何从执行类成功的套接字连接中关闭并重新启动ServerSocket Callable线程？

0 个答案: