Multi-threaded code and condition variable usage

A multi-threaded piece of code accesses a resource (eg: a filesystem) asynchronously.

To achieve this, I'll use condition variables. Suppose the FileSystem is an interface like:

class FileSystem {
    // sends a read request to the fileSystem
    read(String fileName) {
        // ...
        // upon completion, execute a callback
        callback(returnCode, buffer);
    }
}

I have now an application accessing the FileSystem. Suppose I can issue multiple reads through a readFile() method. The开发者_开发问答 operation should write data to the byte buffer passed to it.

// constructor
public Test() {
    FileSystem disk = ...
    boolean readReady = ...
    Lock lock = ...

    Condition responseReady = lock.newCondition();
}

// the read file method in quesiton
public void readFile(String file) {
    try {
        lock.lock(); // lets imagine this operation needs a lock

        // this operation may take a while to complete; 
        // but the method should return immediately
        disk.read(file); 

        while (!readReady) { // <<< THIS
            responseReady.awaitUninterruptibly();
        }
    } 
    finally {
        lock.unlock();
    }
}

public void callback(int returnCode, byte[] buffer) {
    // other code snipped...

    readReady = true;  // <<< AND THIS
    responseReady.signal();
}

Is this the correct way to use condition variables? Will readFile() return immediately?

(I know there is some sillyness in using locks for reads, but writing to a file is also an option.)

There's a lot missing from your question (i.e. no specific mention of Threads) but I will try to answer anyway.

Neither the lock nor the conditional variables give you background capabilities -- they just are used for a thread to wait for signals from other threads. Although you don't mention it, the disk.read(file) method could spawn a thread to do the IO and then return immediately but the caller is going to sit in the readReady loop anyway which seems pointless. If the caller has to wait then it could perform the IO itself.

A better pattern could be to use something like the Java 5 Executors service:

 ExecutorService pool = Executors.newFixedThreadPool(int numThreads);

You can then call pool.submit(Callable) which will submit the job to be performed in the background in another thread (when the pool next has one available). Submit returns a Future which the caller can use to investigate if the background task has finished. It can return a result object as well. The concurrent classes take care of the locking and conditional signal/wait logic for you.

Hope this helps.

p.s. Also, you should make readReady be volatile since it is not synchronized.