Thread Safe

[Shawn Kuenzler]

Are there any situations where you need to make your code thread safe if all it's doing is reading a file? This is kind of beyond the scope of the exam. Are there any file systems that won't allow concurrent read-only access to a file?

[Deepak Bala]

I dont think multiple read operations might require thread safety, since you are not changing the contents of the file in any way.

[Dick Eimers]

Thread safety is only an issue when multiple threads concurrently read a single value AND at least one thread modifies this value at some point in time.

[S Thiyanesh]

Its not 100% that there is no synchronization problems while multiple threads reading from a single file.
Consider

import java.io.*;
class Files implements Runnable{
    File file;
    FileReader fr;
    Files(){
        try{
            file = new File("d:\\sample.txt");
            fr = new FileReader(file);
        }catch(Exception e){
            System.out.println("File Not Found " + e);
        }
    }
 
    public void run(){
        int ch;
        try{
            while((ch = fr.read()) != -1){
                System.out.println((char)ch + " " + Thread.currentThread().getName());
            }
        }catch(Exception e){
            System.out.println("File read error " + e);
        }
    }
}
 
class FileSample{
    public static void main(String args[]){
        Files files = new Files();
        Thread t1 = new Thread(files);
        Thread t2 = new Thread(files);
        t1.start();
        t2.start();
    }
}

Here there is problem as a single thread can't read the file to the fullest.
So when each thread is supplying input to some other process then only a partial data of the file will be available from each thread.
This problem can't even be solved with the synchronized block, but it can be made sure that a single thread reads the whole file and other threads have no data to read at the end of first thread's execution.
To solve this problem you can have a FileReader object inside the run() method to ensure that each thread has the resource to read the same file.

But this example is an inefficient use of thread.