Question

I run a java code that produces a lot of read and write from/to a text file. The program source is very simple and in a loop I write 2000 lines in a test file and then I read them again just to generate a lot of read and write to the disk. But when program is running I monitor the disk by “iostat -d -x 1” I found that there is no change in read in second “r/s” but “w/s” increased as I expected!!!
This is a sample output of iostat command:

Device: rrqm/s wrqm/s  r/s   w/s    rsec/s wsec/s   avgrq-sz avgqu-sz await svctm  %util
sda     0.00   913.00  0.00  82.00  0.00   7872.00   96.00    0.58    7.09   7.11  58.30

Device: rrqm/s wrqm/s  r/s   w/s   rsec/s  wsec/s  avgrq-sz  avgqu-sz  await  svctm  %util
sda     0.00   869.00  0.00  79.00  0.00   7584.00    96.00   0.57    7.11   7.18  56.70

Device: rrqm/s wrqm/s  r/s   w/s   rsec/s  wsec/s  avgrq-sz avgqu-sz   await  svctm  %util
sda     0.00   847.00  0.00  77.00  0.00   7392.00   96.00   0.57      7.42   7.43  57.20

Device: rrqm/s wrqm/s  r/s   w/s   rsec/s  wsec/s   avgrq-sz avgqu-sz  await  svctm  %util
sda     0.00  1221.00  0.00  113.00  0.00  10760.00  95.22    0.84     7.47   7.32  82.70

As it is shown, all “r/s” are zero! but in Java program I read as much as I write in the file?! When I run the Java code, number of write per second increases, but there is no change in ” r/s” !!
Here is java code that I run when monitoring disk :

import java.io.*;

public class Test {

    public static void main(String [] args) throws IOException{

    String fileName = "/scratch/dump_file.txt";
    File f = new File(fileName);
    // Attempt to delete it
    boolean success = f.delete();
    int j=0;
    while(j<20000)
    {
        ++j;
        Writer output = null;
        String text = "A test content";
        File file = new File(fileName);
        output = new BufferedWriter(new FileWriter(file));

        int i=1;
        while(i<2000)
        {
            //Here we start writing 2000 lines into file line by line
            output.write("j==="+Integer.toString(j)+text+Integer.toString(i)+"\n");
            ++i;
        }
        output.close();
        System.out.println("Your file has been written");  

        String line = null;
        try {
            // FileReader reads text files in the default encoding.
            FileReader fileReader = new FileReader(fileName);
            BufferedReader bufferedReader = 
            new BufferedReader(fileReader);
            i=1;
            while((line = bufferedReader.readLine()) != null) {
                //Here we start reading from file line by line and show the result on screen
                ++i;
                System.out.println(line);
            }   
            // Always close file
            bufferedReader.close();         
        }
        catch(FileNotFoundException ex) {
            System.out.println(
                "Unable to open file '" + 
                fileName + "'");                
        }
        catch(IOException ex) {
            System.out.println(
                "Error reading file '" 
                + fileName + "'");                  
            // Or we could just do this: 
            // ex.printStackTrace();
        }
    }
}
}

Answer 1

Most likely, the operating system is caching the file in RAM. Since it’s already cached in memory, when you read in Java the OS doesn’t need to actually read from the disk – it just gives you the cached copy it has already. This is a lot faster than actually reading from disk; note, however, that as iostat only reports actual disk reads and writes, your cached reads won’t show up there.