Question

I am trying to create a continuous thread where a server recieves/sends messages from a client however when I try to check for a next element it gets stuck:

public void run()
{
    try
    {
        try
        {
            ArrayList<Socket> connections = parent.getConnections();
            in = new Scanner(socket.getInputStream());

            while(true)
            {
                if(in.hasNextLine()) // Gets stuck here
                {
                    String message = in.nextLine();
                    System.out.println("Client said " + message);
                }
            }
        }

        finally
        {
            socket.close();
        }
    }

    catch(Exception e)
    {
        e.printStackTrace();
    }

How do I make the loop not get stuck at the specified point

Answer 1

Assuming you want to be able to deal with ‘lines’, I’d probably start with something like this:

public class SocketReader implements Runnable {

    private final InputStream stream;
    private final Queue<String> destination;
    private volatile boolean active = true;

    private SocketReader(InputStream stream, Queue<String> destination) {
        this.stream = stream;
        this.destination = destination;
    }

    public static SocketReader getReader(Socket toRead, Queue<String> destination) throws IOException {
        return new SocketReader(toRead.getInputStream(), destination);
    }

    public void shutdown() {
        active = false;
    }

    public void run() {
        while(active) {
            if (stream.hasNextLine() && active) {
                final String line = stream.nextLine;
                destination.add(line);
            }
        }
        try {
            stream.close();
        } catch (IOException e) {
            // Log somewhere
        }
    }
}

Drop this into its own thread (or as part of a thread or executor pool, really), and you’ve made the rest of your application non-blocking with regards to this code. EXPECT this to block while waiting for updates from stream.hasNextLine(). You can even supply a BlockingQueue if you don’t wish to actively poll a queue, but are handling updates in some other fashion.

You can then do something like this for output:

public class QueuedPrinter implements Runnable {

    private final Queue<String> input;
    private final PrintStream destination;
    private volatile boolean active;

    public QueuedPrinter(Queue<String> input, PrintStream destination) {
        this.input = input;
        this.destination = destination;
    }

    public void shutdown() {
        active = false;
    }

    public void run() {
        while(active) {
            final String line = input.poll();
            if (line != null && active) {
                destination.println(line);
            }
        }
    }

}

Please note that I haven’t tested this, and you may have to adjust things slightly for other Checked exceptions. You probably need to put in additional error-checking code (null-handling comes to mind). Also, this isn’t completely threadsafe, but is likely to be ‘good enough’ for most uses.