Upload file writes too fast in while loop

Question

problem scenerio:
My upload thread occasionally rushes through its while-write loop, writing data for a 3mb image in less than a second and then it waits for a longer time (10-30 seconds) for a response. The thread is writing directly to the OutputStream class using OReilly's implementation. I do not understand this delay. It appears to be buffering? I would like real time progress, which will be reflected in a progress bar. Is there something peculiar about this please:
The corresponding console output is (for each image where the 1657 and 1907 times indicates problematic behavior):
bufferSize: 8192, whileloopWriteTime: 40125, waitForResponseTime: 500
bufferSize: 8192, whileloopWriteTime: 31937, waitForResponseTime: 625
bufferSize: 8192, whileloopWriteTime: 1657, waitForResponseTime: 27843
bufferSize: 8192, whileloopWriteTime: 1907, waitForResponseTime: 33734
bufferSize: 8192, whileloopWriteTime: 48719, waitForResponseTime: 641
bufferSize: 8192, whileloopWriteTime: 34578, waitForResponseTime: 688
upload code (in an applet):
               private int bufferSize = 8192;
               private byte[] buffer = new byte[bufferSize];
               private Socket socket;
               private OutputStream os;
               ..... etc
               os = socket.getOutputStream();
               ..... etc
               // write the file bytes to the socket
               int bytesReadIn=-1;
               while ( ((bytesReadIn = fis.read(buffer)) != -1) )
                    write(buffer, 0, bytesReadIn);
               write(strLFBoundaryLF);
               if(socket != null) socket.shutdownOutput();
               // read response section
               String strResponse="";
               String strInputLine="";
               br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
               while( (strInputLine = br.readLine()) != null ){
                    strResponse=strInputLine.trim();
                    if(strResponse.indexOf("RES:") != -1) break; // contains bytes
                    if(socket==null || !socket.isConnected()){ intError=ERROR_SOCKET; break;}
               if(socket != null) socket.shutdownInput();
....etc
     private void write (byte[] buf,int offset,int size) throws Exception {
               os.write (buf,offset,size);
============================================================================
jsp page receives the call from the applet:
          else if (part.isFile()) {
               FilePart filePart = (FilePart)part;
               String fileName = filePart.getFileName();
               String filePath = filePart.getFilePath();
               String strServerFilePath = fileInfoStorage.getServerFilePath(filePath);
               File SaveFile = new File (strServerFilePath);
               (SaveFile.getParentFile()).mkdirs();
               if(fileName != null) {
                    FileOutputStream outStream = null;
                    try {
                    outStream = new FileOutputStream(SaveFile);
                    lgBytesTransferred += filePart.writeTo(outStream); // writes directly to the file
                    outStream.flush();
... etc
=========================================================================
package com.oreilly.servlet.multipart;
FilePart class
... etc
long write(OutputStream out)
throws IOException
if(contentType.equals("application/x-macbinary"))
out = new MacBinaryDecoderOutputStream(out);
size = 0L;
byte buf[] = new byte[8192];
int read;
while((read = partInput.read(buf)) != -1)
out.write(buf, 0, read);
size += read;
return size;
public long writeTo(OutputStream out)
throws IOException
long size = 0L;
if(fileName != null)
size = write(out);
return size;
}

Answer 1

Thank you for your responses.
Accurately reporting the upload progress to the user is required, however a timely upload is also imporrtant.
At present data appears to be sitting in a buffer for 10-20 seconds, while the progress bar indicates complete and before the next file upload is
started.
I am not using swing. I use an (non-gui) applet which handles communication between the server (jsp, servlet) and a dhtml, css interface.
In the gui I a list of items awaiting upload is created. The gui paints a progress bar next to an item which is in progress (uploading).
When an individual item's progress bar reaches 100% (confirmed to disk) the text 'complete' replaces the progress bar.and a the next item receives a progress bar. The gui also paints updates to a second global progress bar which indicates overall progress. The uploads are reliable, but for this issue.
There's not much information except timing information in your post, and what would help us make educated guesses into what your program does are "etc."ed. Notably, does your applet maintain a single connection to your server for all image uploads?
Presently the applet creates a new socket for each request. Another class manages and monitors the socket connection. The socket connection
runs in its own thread. At the end of each file upload the socket and thread terminate. Once the upload behavior is stable I will attempt a more
elaborate thread and socket management scheme.
>
Try acquiring more information with a network analyser such as Wireshark.
I have wireshark. I will try and post results. However I placed a System.out.println in the
O'Reilly class which receives the data and it appears to receive and write the file data (via OutputStream.write) in 1-2 seconds as
reflected in the applet output.
>
This bizarre suggestion at least contains the germ of the issue. Your writes are just writing to the socket send buffer, not to the network. I would
increase the socket send buffer size personally.
I have not tested an increased socket send buffer size. This feels right. I will test this tomorrow and report back. Do you have a suggested socket send buffer size?
Your suggestion that I am writing to the socket and not the network would certainly reflect the results I am witnessing.
In the O'Reilly class data is being written from the incoming stream (8192 bytes per loop) to the file using the OutputStream write method. However because the data is writes are so fast it appears to be writing to a buffer and not the file.
Yeah. Next question is is this really the O'Reilly code? that keeps testing the socket for null and isConnected() after it's already been in use and can't possibly be in any other state?
This code which is testing the socket is not the O'Reilly code. The O'Reilly code is the FilePart class.