从套接字流读取的线程占用更多的CPU使用率

Question

In client socket, I wrote a thread to read the socket's inputStream continuously. Here I have used a while loop to read infinitely. However it takes more CPU; hence is it possible to reduce the CPU. Please add your suggestions. Also is it possible to add listeners for inputStream.

Thread code:

public void run() {
while (!shutdown) {
    try {
        if(socketClient != null) {
            String message = socketClient.getMessage();
            logger.info ("Message size:" + message.length ());
            if(!message.equals("EmptyString")) {
                process(message);
            }
        } 
    } catch (Exception exception) {
        logger.info("Unable to read the socket message" +exception);
    }
}

}

SocketClient.java

public class SocketClient{
private volatile boolean isConnected;
private int              port;
private int              retryCount;
private long             startTime;
private String           hostName;
private DataInputStream  input;
private DataOutputStream output;
private Socket           socket;

public SocketClient(int port, String hostname) throws IOException {
    this.port     = port;
    this.hostName = hostname;
    establishConnection();
}


public void shutdown() {
    try {
        shutdown = true;
        input.close();
        output.close();
        socket.close();
    } catch (Exception e) {
        logger.debug("Exception in shutdown:" + e.getMessage());
    }
}

        public String getMessage() {
    BufferedReader reader = null;

    try {
        StringBuilder builder = new StringBuilder();
        reader = new BufferedReader(new 
                        InputStreamReader(tcpSocket.getInputStream()));

        do {
            builder.append(reader.readLine());
        } while((reader.ready()));

        if (builder.length() == 0)
            return "EmptyString";

        return builder.toString();
    } catch (IOException e) {
            return "EmptyString";
    } finally {
        try {
            if(reader != null)
                reader.close();
        } catch(IOException e) {
            logger.error("unable to close reader");
        }
    }
}

    private void establishConnection() {
        retryCount = 1;
        startTime  = System.currentTimeMillis();

        while (!shutdown) {
            try {
                if(!isConnected) {
                    socket = new Socket(hostName,port);
                    socket.setKeepAlive(true);
                    input       = new DataInputStream(socket.getInputStream());
                    output      = new DataOutputStream(socket.getOutputStream());
                    isConnected = true;
                    shutdown    = true;
                } 
            } catch (Exception exception) {
                isConnected = false;
                sleepFewSeconds();
                reconnectSocket();
            }
        }
    }

    private void reconnectSocket() {
        long endTime = startTime + 120000L;

        if(!(System.currentTimeMillis() < endTime)) {
            shutdown = true;
        }   
    }

    private void sleepFewSeconds() {
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException interruptedException) {
            shutdown = true;
        }
    }

}

Answer 1

I am going to critique the entire class here. The answer to your specific question will appear.

public class SocketClient{
private volatile boolean isConnected;

You don't need this. socket == null would do just as well.

private int              port;
private int              retryCount;
private long             startTime;
private String           hostName;
private DataInputStream  input;
private DataOutputStream output;
private Socket           socket;

public SocketClient(int port, String hostname) throws IOException {
    this.port     = port;
    this.hostName = hostname;
    establishConnection();
}


public void shutdown() {
    try {
        shutdown = true;
        input.close();
        output.close();
        socket.close();

You don't need all these closes, and you're doing them in the wrong order anyway. output.close() is sufficient and in any case it should certainly be first.

    } catch (Exception e) {
        logger.debug("Exception in shutdown:" + e.getMessage());
    }
}

public String getMessage() {
    BufferedReader reader = null;

The BufferedReader should be an instance variable, not a local variable. It's buffered. If you make it a local variable you will lose data.

    try {
        StringBuilder builder = new StringBuilder();
        reader = new BufferedReader(new 
                        InputStreamReader(tcpSocket.getInputStream()));

        do {
            builder.append(reader.readLine());
        } while((reader.ready()));

You don't need all this. If the message is a single line, all you need is return reader.readLine() , and you need the caller to check whether it was null, and if so close the socket, cease reading, etc. If the message is more than one line, this is a misuse of ready() : it is certainly not an indicator of end of message. It appears from comments under your question that you shouldn't even have the method : just connect the socket input stream directly to your XML parser and let it do the reading.

        if (builder.length() == 0)
            return "EmptyString";

Don't do this. Return "" or null. Don't make up new magic strings for your application to have to decode.

        return builder.toString();
    } catch (IOException e) {
            return "EmptyString";

Ditto.

    } finally {
        try {
            if(reader != null)
                reader.close();

You should not close the reader here. Closing it will close the socket, so you can never get another message.

        } catch(IOException e) {
            logger.error("unable to close reader");
        }
    }
}

private void establishConnection() {
        retryCount = 1;
        startTime  = System.currentTimeMillis();

        while (!shutdown) {
            try {
                if(!isConnected) {
                    socket = new Socket(hostName,port);
                    socket.setKeepAlive(true);
                    input       = new DataInputStream(socket.getInputStream());
                    output      = new DataOutputStream(socket.getOutputStream());
                    isConnected = true;
                    shutdown    = true;

Why are you setting shutdown to true here? Nothing is shutdown yet. It's a brand new socket.

                } 
            } catch (Exception exception) {
                isConnected = false;
                sleepFewSeconds();
                reconnectSocket();
            }

Poor practice. Socket.connect() , which is called internally by new Socket(...) , already retries, and also you should distinguish between connection-failure exceptions rather than adopt the same strategy for them all. For example, a 'connection timeout' will already have blocked for a minute or so: you don't need another sleep; and 'connection refused' means there is nothing listening, so retrying is completely pointless.

    private void reconnectSocket() {
        long endTime = startTime + 120000L;

        if(!(System.currentTimeMillis() < endTime)) {
            shutdown = true;
        }   
    }

    private void sleepFewSeconds() {
        try {
            TimeUnit.MILLISECONDS.sleep(20);

This is not a 'few seconds'. It is 20 milliseconds , and that is not enough by at least two orders of magnite in network programming, to the extent that there should be any sleep at all of course.

        } catch (InterruptedException interruptedException) {
            shutdown = true;

shutdown appears to be never false. I doubt that you've thought through what it really means, and I doubt that you really need it at all.

As for your calling code:

public void run() {
while (!shutdown) {
    try {
        if(socketClient != null) {

If socketClient is null this loop will spin meaninglessly. Surely this method should construct the socket client?

            String message = socketClient.getMessage();
            logger.info ("Message size:" + message.length ());

Here you are failing to check for null and failing to respond appropriately, which would be to close the socket and exit the loop. Instead you will get an NPE here.

            if(!message.equals("EmptyString")) {
                process(message);

See above. Don't send yourself special text messages. What happens if the peer needs to send that one day?

            }
        } 
    } catch (Exception exception) {
        logger.info("Unable to read the socket message" +exception);

Unacceptable. This catch is inside the loop and it essentially ignores the exception. The result is that, again, this loop will spin meaninglessly on any exception. And the methods you're calling should be declared to throw IOException , and that is all you should catch here. At present you will spin even on NullPointerException .

Answer 2

i see you are facing a lot of problem due to high disk usage of your system that many times leads to lagging.Well i have the solution to your problem i found this link on internet..really a helping article http://errorcodespro.com/tiworker-exe-high-disk-usage-windows/ . At begining i thought it was because of hard drive failure but i applied the solution it worked very well. You can find your solution at the given system.