First Socket read thru BufferedReader is slow - rest faster

Question

When I do the first read on a BufferedReader which is created against a Socket, it is taking about 1200 ms. Each subsequent read takes less than 200 ms. Is there something I can do to improve the performance of the first read? If I switch from the BufferedReader and do the reading myself, will I see better performance? The code snip follows.
Thanks,
Dave Y.
The BufferReader is set up this way:
try
m_Socket = new Socket(machine, port);
m_Socket.setTcpNoDelay(true);
m_Writer = new PrintWriter(m_Socket.getOutputStream(), true); // Auto flush.
m_Reader = new BufferedReader(new InputStreamReader(m_Socket.getInputStream()));
catch (UnknownHostException e)
blah blah
catch (IOException e)
blah blah
The reading code is this:
// Read back the answer....
int bufSize = 1024; // Nasty hard code.
int readSize = 0;
String eomSearch = m_MessageOut.getSegmentTerminator() + "EOM|";
String searchString;
char theResponse[] = new char[bufSize];
StringBuffer sb = new StringBuffer(8096);
boolean fMoreData = true;
long startReadTS;
long endReadTS;
int i = 0;
try
while ( fMoreData )
startReadTS = System.currentTimeMillis();
readSize = m_Reader.read (theResponse, 0, bufSize);
endReadTS = System.currentTimeMillis();
System.out.println("Read " + i++ + " took: " + (endReadTS - startReadTS) + " ms. Size: " + readSize);
if (readSize == -1)
fMoreData = false;
else
sb.append(theResponse, 0, readSize);
// Now try to find data that indicates end of message
// so we do not have to wait for the Socket timeout.
searchString = new String(theResponse);
if (searchString.indexOf(eomSearch) >= 0)
fMoreData = false;
catch (IOException e)
MyResultChain rc = new MyResultChain();
rc.recordThenAdd(new MySystemResult("send() reading from: " + m_AppServer,ERROR_SOCKET_READ));
throw rc;

Answer 1

The first call on BufferedReader is effectively calling the underlying input stream's read(buf) method, which would try to read a chunk of bytes from the underlying input stream, the following calls works like this:
1. if the buf is not empty, return byte(s) in the buf.
2. if most bytes in the buf have been read, the BufferReader would invoke underlying input stream's read(buf) to read some more bytes and fill its buf.
So, the first call could be a block call as it calls the input stream's read(), so it could take some time to return, the following calls mainly returns bytes in the buf, so it's much faster than the first call, of course, you have to consider the filling time when the BufferReader needs to fill its buf. Basically, BufferedReader is faster if you have lots of read() (one bytes or so) methods, if you keep reading like read(buf) which reads an array of bytes, then use the input stream directly could be slightly faster.
My $0.02