Hello,

I need help understanding how the readline() method of a BufferedReader object works in Java.

From what I understanding when a BufferedReader object reads from a file using the readline() method it reads the file line by line and when there is nothing left to read the method returns a null (The code labelled Example1 is an illustration of this).

However I don’t understand how the readline() method works when reading from a socket. Please refer to the code labelled as Example 2. A Client program that connects to the server illustrated in Example 2 can send text any time and can wait long periods of time between sending text to the server.

How does the java virtual machine know when the end of the stream related to the socket has been reached so that readline() can return null?

Example 1:

import java.io.*;

class Reader{
  public static void main(String[] args){
  int lineCount = 0;
   
  try {
    File myFile = new File("Reader.java");
    FileReader fileReader = new FileReader(myFile);
   
    BufferedReader reader = new BufferedReader(fileReader);
   
    String line = null;
     // *** My question is about the next line **/
    while( (line = reader.readLine()) != null ) {
       System.out.println(++lineCount + " " + line);
    }
    reader.close();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  System.out.println("lineCount = " + lineCount);
  }
}

Example 2

import java.io.*;
import java.net.*;
import java.util.*;


public class VerySimpleChatServer
{
  ArrayList clientOutputStreams;
   
  public class ClientHandler implements Runnable {
  BufferedReader reader;
  Socket sock;
   
  public ClientHandler(Socket clientSOcket) {
  try {
  sock = clientSOcket;
  InputStreamReader isReader = new InputStreamReader(sock.getInputStream());
  reader = new BufferedReader(isReader);
   
  } catch (Exception ex) { ex.printStackTrace(); }
  }
   
  public void run() {
  String message;
  try {
   // *** My question is about the next line **/
  while ((message = reader.readLine()) != null) {
  System.out.println("read " + message);
  tellEveryone(message);
  }
  } catch (Exception ex) { ex.printStackTrace(); }
  }
  }
   
  public static void main(String[] args) {
  new VerySimpleChatServer().go();
  }
   
  public void go() {
  clientOutputStreams = new ArrayList();
  try {
  ServerSocket serverSock = new ServerSocket(5000);
  while(true) {
  Socket clientSocket = serverSock.accept();
  PrintWriter writer = new PrintWriter(clientSocket.getOutputStream());
  clientOutputStreams.add(writer);
   
  Thread t = new Thread(new ClientHandler(clientSocket));
  t.start();
  System.out.println("got a connection");
  }
  } catch (Exception ex) { ex.printStackTrace(); }
  }
   
  public void tellEveryone(String message) {
  Iterator it = clientOutputStreams.iterator();
  while (it.hasNext()) {
  try {
  PrintWriter writer = (PrintWriter) it.next();
  writer.println(message);
  writer.flush();
  } catch (Exception ex) { ex.printStackTrace(); }
  }
  }
}

Source of Code: Head First Java 2nd edition – Chap 15

 

In example 2 notice that the BufferedStreamReader wraps an InputStreamReader which wraps the socket InputStream. This is a way of effectively adding extra functionality to the stream, InputStreamReader only supports reading a char or a number of chars into an array. BufferedStreamReader adds readLine which presumably reads chars from the input stream and buffers them until a line ending char is encountered at which point it returns the line as a string.

InputStreamReader.read returns -1 when the end of stream is reached, BufferedStreamReader presumbaly detects this and returns null from readLine

 

InputStreamReader.read returns -1 when the end of stream is reached, BufferedStreamReader presumbaly detects this and returns null from readLine

Thank you for your response. I took a look at https://docs.oracle.com/javase/7/docs/api/java/io/InputStreamReader.html#read()

However I am still curious as to what signals that the end of the stream has been reached?
The book I am reading compares a stream to a pipe with bits going from one end to the other.
Thinking about how a chat client works there are moments of bursts of bits when someone sends a message and long moments when no one is sending a message. However this "silence" on the pipe does not mean that the end of the stream has been reached because a message can still be sent on the pipe after a moment of "silence".

There is "silence" on the pipe between lines 2 and 3:
1: Person1<9:00>: hello
2: Person2<9:00>: hello Person1
3: Person3<9:05>: how are you?

 

I believe it depends on the underlying protocol but for TCP at least there is no "closed" message and so it generally just relies on time outs.

 

The server disconnects. You did not post the whole VerySimpleChatServer. Some where in the server code, "close" will be called on the ServerSocket object.