2

It seems pretty clear that using readLock when reading from a file (for example), and using writeLock when writing to it is appropriate. However, if I have an operation where two values are being compared, such as:

if (i == j) {
    System.out.println("equal);
}

Then is it okay to use readLock() instead of writeLock to lock this code? Granted, I'm not writing anything, but I am comparing two values, which is bit different than just reading data since there is an operation involved. Keep in mind that "i" or "j" could change at any time. In theory, readLock() will only move forward if a writeLock() is not modifying the resource, but I may not fully understand all the complexities of this issue. It just seems like there is potential for a bit of a grey area so I thought I'd get some input.

Thanks to everyone,

Matt

Swifty McSwifterton
  • 2,637
  • 1
  • 30
  • 37

2 Answers2

4

Don't think about read/write locks in terms of reading and writing, think of them as exclusive/shared. A write lock is exclusive, a read lock is shared.

To answer your question, it depends.

Say you had 1 thread which was updating i, and one thread which was updating j, and another thread that was checking for equality. In that case the writing threads would acquire a shared (read) lock, since they can both operate in parallel, since each thread only updates 1 variable. The compare thread could then acquire an exclusive lock (write lock) to compare and perform an action, preventing any updates while the action was being performed.

So think in terms of exclusive/shared, and what the needs of your application are.

sbridges
  • 24,960
  • 4
  • 64
  • 71
  • You make a good point about exclusive and shared. The two values I am comparing in my real code come from 1) a method (which is locked where necessary) in another class that returns a value, and 2) a local variable from my method that is not synchronized. These variables can change instantly if another thread calls them, but the readLock() should pick up on that and stop reading these values if they are changing right? Thanks very much to everyone. – Swifty McSwifterton Mar 16 '11 at 06:17
0

Though I think making i and j as volatile and synchronizing modification accesses to it should be enough.

But say that you have to use read-write locks. In that case for your above code you need to have a read-lock. The reason is your given code is a non-modification code, it doesn't modify i or j. So other methods could indeed read value of i and j parallely without any corruption. You would use write lock only in places that are modifying values of i and j.

Edit: Highlighted "synchronizing modification accesses to it" to answer the comments

Suraj Chandran
  • 24,433
  • 12
  • 63
  • 94
  • @user654801 yes exactly, you also have to synchronize the modification accesses which i have already mentioned in my answer. – Suraj Chandran Mar 16 '11 at 05:31