java - 如何在JAVA中正确关闭java SocketChannel？

Question

我正在用Java开发多线程非阻塞tcp服务器和客户端。我在服务器意识到客户端套接字已关闭时遇到问题。对他来说一切都是开放的。这是代码和我的代码的输出:

服务器:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package androidnonblockingnewesttest;

import globalvariables.*;
import interface_package.*;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.InetSocketAddress;
import java.nio.channels.Channels;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

/**
 *
 * @author wsserver
 */
public class AndroidNonBlockingNewestTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Prevzemi staticen interface
        GlobalVariables.sinterface = new ServerInterface();
        GlobalVariables.sinterface.show();

        //POSTAVI SERVER
        //INFINITE LOOP
        //NE MOZAM POSLE OVA DA POVIKUVAM NISTO BIDEJKI NEMA DA STIGNE DO NEGO PORADI while(true)
        int port = GlobalVariables.portNo;

        ServerSocketChannel serverSocket = null;
        try {
            serverSocket = ServerSocketChannel.open();
            serverSocket.socket().bind(new InetSocketAddress(port));
            serverSocket.configureBlocking(false);
            System.out.println("Server has started listening on port " + port);
            GlobalVariables.sinterface.setServerStatus("Server has started listening on port " + port);
            GlobalVariables.sinterface.setReceivedText("Server has started listening on port " + port);
        } catch (IOException e) {
            System.out.println("Error: Cannot listen on port " + port + " : " + e);
            GlobalVariables.sinterface.setServerStatus("Error: Cannot listen on port " + port + " : " + e);
            GlobalVariables.sinterface.setReceivedText("Error: Cannot listen on port " + port + " : " + e);
            System.exit(1);
        }
        while (true) // infinite loop - loops once for each client
        {
            SocketChannel clientSocket = null;
            try {
                clientSocket = serverSocket.accept(); //waits here (forever) until a client connects

                if (clientSocket == null) {
                    // No connections came .
                } else {
                    clientSocket.configureBlocking(false);
                    // You got a connection. Do something
                    System.out.println("Server has just accepted socket connection from a client");
                    GlobalVariables.sinterface.setServerStatus("Server has just accepted socket connection from a client");
                    GlobalVariables.sinterface.setReceivedText("Server has just accepted socket connection from a client");

                    // Create the Handle Connection object - our new thread object - only create it
                    ThreadedHandleConnection con = new ThreadedHandleConnection(clientSocket);

                    if (con == null) //If it failed send and error message
                    {
                        try {
                            ObjectOutputStream os = new ObjectOutputStream(Channels.newOutputStream(clientSocket));
                            os.writeObject("error: Cannot open socket thread");
                            GlobalVariables.sinterface.setReceivedText("error: Cannot open socket thread");
                            os.flush();
                            os.close();
                        } catch (Exception ex) //failed to even send an error message
                        {
                            System.out.println("Cannot send error back to client: " + ex);
                            GlobalVariables.sinterface.setServerStatus("Cannot send error back to client: " + ex);
                            GlobalVariables.sinterface.setReceivedText("Cannot send error back to client: " + ex);
                        }
                    } else {
                        con.start();
                    } // otherwise we have not failed to create the HandleConnection object
                    // start this thread now
                }
            } catch (IOException e) {
                System.out.println("Accept failed: " + e);
                GlobalVariables.sinterface.setServerStatus("Accept failed: " + e);
                GlobalVariables.sinterface.setReceivedText("Accept failed: " + e);
                break;
            }
        }

        try // do not get here at the moment 
        {
            System.out.println("Closing server socket.");
            GlobalVariables.sinterface.setServerStatus("Closing server socket.");
            GlobalVariables.sinterface.setReceivedText("Closing server socket.");
            serverSocket.close();
        } catch (IOException e) {
            System.err.println("Could not close server socket. " + e.getMessage());
            GlobalVariables.sinterface.setServerStatus("Could not close server socket. " + e.getMessage());
            GlobalVariables.sinterface.setReceivedText("Could not close server socket. " + e.getMessage());
        }
    }
}

连接处理程序:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package androidnonblockingnewesttest;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

/**
 *
 * @author wsserver
 */
public class ThreadedHandleConnection extends Thread {

    private SocketChannel clientSocket;
    Charset charset = Charset.forName("ISO-8859-1");
    CharsetEncoder encoder = charset.newEncoder();
    CharsetDecoder decoder = charset.newDecoder();
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // The constructor for the connecton handler
    public ThreadedHandleConnection(SocketChannel clientSocket) {
        try {
            this.clientSocket = clientSocket;
            clientSocket.configureBlocking(false);
        } catch (IOException ex) {
            System.out.println("SocketChannel blocking exception: " + ex.getMessage());
        }
    }

    // The main thread execution method 
    @Override
    public void run() {
        while (!clientSocket.socket().isClosed()) {

            try {

                System.out.println("Socket status:clientSocket.isConnected():" + clientSocket.isConnected());
                System.out.println("Socket status:clientSocket.finishConnect():" + clientSocket.finishConnect());
                System.out.println("Socket status:clientSocket.isOpen():" + clientSocket.isOpen());
                System.out.println("Socket status:clientSocket.socket().isClosed():" + clientSocket.socket().isClosed());
                System.out.println("Socket status:clientSocket.socket().isClosed():" + clientSocket.socket().isConnected());


                int bytesread = clientSocket.read(buffer);
                if (!(bytesread > 0)) {
                    System.out.println("Nothing to read");
                } else {
                    buffer.flip();

                    String request = decoder.decode(buffer).toString();

                    System.out.println("Request:" + request);
                    buffer.clear();
                }
                Thread.sleep(3000);
            } catch (IOException ex) {
                System.out.println("Socket run exception " + ex.getMessage());
            } catch (Exception ex) {
                System.out.println("Exception " + ex.getMessage());
            }
        }
    }
}

客户:

package androidnonblockingnewesttest;

import globalvariables.GlobalVariables;
import java.io.*;
import java.net.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author wsserver
 */
public class ThreadedTCPClient {

    private SocketChannel socket = null;
    String serverIP = GlobalVariables.serverIP;
    int port = GlobalVariables.portNo;

    Charset charset = Charset.forName("ISO-8859-1");
    CharsetEncoder encoder = charset.newEncoder();
    CharsetDecoder decoder = charset.newDecoder();
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // the constructor expects the IP address of the server
    public ThreadedTCPClient() {
        if (!connectToServer()) {
            System.out.println("Cannot open socket connection...");
        }
    }

    private boolean connectToServer() {
        try // open a new socket to port:  and create streams
        {
            this.socket = SocketChannel.open();
            this.socket.configureBlocking(false);
            this.socket.connect(new InetSocketAddress("localhost", port));
            while(!this.socket.finishConnect()){

            }
            System.out.print("Connected to Server\n");

        } catch (Exception ex) {
            System.out.print("Failed to Connect to Server\n" + ex.toString());
            System.out.println(ex.toString());
            return false;
        }
        return true;
    }

    public void sendTest() {
        try {
            buffer = encoder.encode(CharBuffer.wrap("Hellow from client"));
            socket.write(buffer);
            buffer.clear();
        } catch (IOException ex) {
            System.out.println("Write exception: "+ex.getMessage());
        }
    }

    public void closeConnection(){
        try{
            this.socket.socket().close();
            this.socket.close();
            System.out.println("Close");
        }catch(Exception ex){
            System.out.print("Failed to close connection to Server\n" + ex.toString());
            System.out.println(ex.toString());
        }
    }

    public static void main(String args[]) {

        ThreadedTCPClient theApp = new ThreadedTCPClient();
        try {
            Thread.sleep(10000);
            theApp.sendTest();
            theApp.closeConnection();
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }

    }
}

这是我的输出。客户端输出:

Connected to Server
Close

服务器的输出:

Server has started listening on port 10001
Server has just accepted socket connection from a client
Socket status:clientSocket.isConnected():true
Socket status:clientSocket.finishConnect():true
Socket status:clientSocket.isOpen():true
Socket status:clientSocket.socket().isClosed():false
Socket status:clientSocket.socket().isClosed():true
Nothing to read
Socket status:clientSocket.isConnected():true
Socket status:clientSocket.finishConnect():true
Socket status:clientSocket.isOpen():true
Socket status:clientSocket.socket().isClosed():false
Socket status:clientSocket.socket().isClosed():true
Nothing to read
...
Socket status:clientSocket.isConnected():true
Socket status:clientSocket.finishConnect():true
Socket status:clientSocket.isOpen():true
Socket status:clientSocket.socket().isClosed():false
Socket status:clientSocket.socket().isClosed():true
Request:Hellow from client
Socket status:clientSocket.isConnected():true
Socket status:clientSocket.finishConnect():true
Socket status:clientSocket.isOpen():true
Socket status:clientSocket.socket().isClosed():false
Socket status:clientSocket.socket().isClosed():true
Nothing to read
...

关闭客户端连接后，所有 SocketChannel 和 SocketChannel.socket() 状态都不会改变。请帮忙。

Answer 1

您的代码在很多方面都是错误的。

1. 如果您使用非阻塞 I/O，您当然也应该使用 Selector，而不是在 accept() 中疯狂旋转，finishConnect() 等

2. isClosed() 不会告诉您对等点是否已关闭。它告诉您您是否已关闭。如果对等点已关闭，read() 将返回 -1。类似地，isConnected() 仅告诉您是否您曾经连接过套接字。你这样做了，所以重复调用它是没有意义的。

3. 在非阻塞模式下连接的正确方法是 (a) 调用 connect(), (b) 选择 OP_CONNECT, (c)当它触发时调用 finishConnect()，并且 (d) 当且仅当返回 true 时，取消对 OP_CONNECT 的兴趣。

4. 如果在非阻塞模式下收到任何IOException，则必须关闭 channel 。

5. “多线程非阻塞服务器”在术语上近乎矛盾。如果有线程，则阻塞。如果您有非阻塞模式，请选择。