OutputStream closes FileReader

Question

Hi all,
I've been doing some tests about concurrent file access and i've found something that i don't understand..
I've implementet two thread-extended classes, one that accesses a file via FileInputStream and reads it's content, and another one that writes into the same file via FileOutputStream (while the reader thread is still reading the file).
If I start some reader threads them begin reading the file ok, but when the writter thread starts and accesses the same file, every reader thread stops because of a suddenly EOF found.
This means that FileReader doesn't lock the files it accesses? Should it be the right behavior? I mean, wouldn't be safer that a FileOutputStream were not able to access a file that is been already accessed by a FileInputStream?
This is the code that I used for testing:
package iotests;
import java.io.FileOutputStream;
public class IOTWriterThread extends Thread {
     private String filename;
     private int iterations;
     private int waitTime; //millis that the thread will wait every time that write a byte
     private String threadId;
     public IOTWriterThread(String pFn, int pI, int pWT){
          this.filename = pFn;
          this.iterations = pI;
          this.waitTime = pWT;
          this.threadId = Long.toString(System.currentTimeMillis());
     public void run(){
          FileOutputStream fos = null;
          try{
               fos = new FileOutputStream(this.filename);
               for(int i=0;i<this.iterations;i++){
                    fos.write(65); //write 'A' char
                    System.out.println("{writter["+this.threadId+"]/iteration["+i+"]}");
                    Thread.sleep((long)this.waitTime);
               System.out.println("{writter["+this.threadId+"]/end of writting.}");
          }catch(Exception ex){
               System.out.println("Exception writting file ["+this.filename+"].");
          }finally{
               this.closeFOS(fos);
               fos = null;               
     private void closeFOS(FileOutputStream pFos){
          if(pFos != null){
               try{
                    pFos.close();
               }catch(Exception e){
                    e.printStackTrace();
package iotests;
import java.io.FileInputStream;
public class IOTReaderThread extends Thread {
     private String filename;
     private String threadId;
     private int waitTime; //millis that the thread will wait every time that read a byte
     public IOTReaderThread(String pFn, int pWT){
          this.filename = pFn;
          this.waitTime = pWT;
          this.threadId = Long.toString(System.currentTimeMillis());
     public void run(){
          FileInputStream fis = null;
          try{
               fis = new FileInputStream(this.filename);
               int readed;
               while((readed=fis.read())!=-1){
                    System.out.println("{reader["+this.threadId+"]/readed["+readed+"]}");
                    Thread.sleep((long)this.waitTime);
               System.out.println("{reader["+this.threadId+"]/EOF reached.}");
          }catch(Exception ex){
               System.out.println("{reader["+this.threadId+"]/EXCEPTION["+ex.getMessage()+"]}");
          }finally{
               this.closeFIS(fis);
               fis = null;
     private void closeFIS(FileInputStream pFis){
          if(pFis != null){
               try{
                    pFis.close();
               }catch(Exception e){
                    e.printStackTrace();
package iotests;
import iotests.IOTWriterThread;
import iotests.IOTReaderThread;
public class IOTestClass {
     private int waitTime;
     public IOTestClass(int pWT){
          this.waitTime = pWT;
     public void go(){
          // read the original file (thread1)
          IOTReaderThread iotr1 = new IOTReaderThread("c:\\file.txt",this.waitTime);
          iotr1.start();
          //wait some millis
          try{Thread.sleep(50);}catch(Exception e1){}
          // read the original file (thread2)
          IOTReaderThread iotr2 = new IOTReaderThread("c:\\file.txt",this.waitTime);
          iotr2.start();
          //wait some millis
          try{Thread.sleep(50);}catch(Exception e1){}
          // read the original file (thread3)
          IOTReaderThread iotr3 = new IOTReaderThread("c:\\file.txt",this.waitTime);
          iotr3.start();
          //wait some millis
          try{Thread.sleep(1000);}catch(Exception e1){}          
          // write in the same file (while reader is still reading the original file)
          // this will force a EOF to any reader thread
          IOTWriterThread iotw1 = new IOTWriterThread("c:\\file.txt",5,this.waitTime);
          iotw1.start();     
          //wait some millis
          try{Thread.sleep(500);}catch(Exception e1){}
          // read the same file, that now is being written
          IOTReaderThread iotr4 = new IOTReaderThread("c:\\file.txt",this.waitTime);
          iotr4.start();
      * @param args
     public static void main(String[] args) {
          IOTestClass IOTC = new IOTestClass(500);
          IOTC.go();
}

Answer 1

Yes...when you chain readers/writers together, you only need close the outermost reader/writer and all the inner ones close automatically.