I'm sorry to hear it was common to see server software written that did a
readLine().

One of the drawbacks of Java is that it provides a surface simplicity that
can disguise complex issues.  It can fool people into thinking that building
a multi-threaded server is as simple:as scattering some 'synchronized's
around, or that persistence can be addressed merely by declaring that some
classes implement Serializeable.

here is the main method in BufferedReader.readLine . It does not
return until it has hit EOL.

   /**
    * Read a line of text.  A line is considered to be terminated by
any one
    * of a line feed ('\n'), a carriage return ('\r'), or a carriage
return
    * followed immediately by a linefeed.
    *
    * @param      ignoreLF  If true, the next '\n' will be skipped
    *
    * @return     A String containing the contents of the line, not
including
    *             any line-termination characters, or null if the end
of the
    *             stream has been reached
    *
    * @see        java.io.LineNumberReader#readLine()
    *
    * @exception  IOException  If an I/O error occurs
    */
   String readLine(boolean ignoreLF) throws IOException {
       StringBuffer s = null;
       int startChar;
       boolean omitLF = ignoreLF || skipLF;

       synchronized (lock) {
           ensureOpen();

       bufferLoop:
           for (;;) {

               if (nextChar >= nChars)
                   fill();
               if (nextChar >= nChars) { /* EOF */
                   if (s != null && s.length() > 0)
                       return s.toString();
                   else
                       return null;
               }
               boolean eol = false;
               char c = 0;
               int i;

               /* Skip a leftover '\n', if necessary */
               if (omitLF && (cb[nextChar] == '\n'))
                   nextChar++;
               skipLF = false;
               omitLF = false;

           charLoop:
               for (i = nextChar; i < nChars; i++) {
                   c = cb[i];
                   if ((c == '\n') || (c == '\r')) {
                       eol = true;
                       break charLoop;
                   }
               }

               startChar = nextChar;
               nextChar = i;

               if (eol) {
                   String str;
                   if (s == null) {
                       str = new String(cb, startChar, i -
startChar);
                   } else {
                       s.append(cb, startChar, i - startChar);
                       str = s.toString();
                   }
                   nextChar++;
                   if (c == '\r') {
                       skipLF = true;
                   }
                   return str;
               }
               
               if (s == null)
                   s = new StringBuffer(defaultExpectedLineLength);
               s.append(cb, startChar, i - startChar);
           }
       }
   }

  /**
    * Fill the input buffer, taking the mark into account if it is
valid.
    */
   private void fill() throws IOException {
       int dst;
       if (markedChar <= UNMARKED) {
           /* No mark */
           dst = 0;
       } else {
           /* Marked */
           int delta = nextChar - markedChar;
           if (delta >= readAheadLimit) {
               /* Gone past read-ahead limit: Invalidate mark */
               markedChar = INVALIDATED;
               readAheadLimit = 0;
               dst = 0;
           } else {
               if (readAheadLimit <= cb.length) {
                   /* Shuffle in the current buffer */
                   System.arraycopy(cb, markedChar, cb, 0, delta);
                   markedChar = 0;
                   dst = delta;
               } else {
                   /* Reallocate buffer to accommodate read-ahead
limit */
                   char ncb[] = new char[readAheadLimit];
                   System.arraycopy(cb, markedChar, ncb, 0, delta);
                   cb = ncb;
                   markedChar = 0;
                   dst = delta;
               }
               nextChar = nChars = delta;
           }
       }

       int n;
       do {
           n = in.read(cb, dst, cb.length - dst);
       } while (n == 0);
       if (n > 0) {
           nChars = dst + n;
           nextChar = dst;
       }
   }