Java optimized read/write a shared resource/memory location without Atomic API e.g. AtomicInteger

Question

There is a shared resource and we need to perform read/write operations on it as per below:

When a write on resource is going on then no read should be allowed.
When a read is going on then no write should be allowed but multiple read threads should be able to read.

I have written code like mentioned below but the problem with this code is all reads will be blocked when a single read thread has acquired the lock. Further i am thinking to use a boolean flag e.g. canReadContinue. Now the first time when read acquires a lock i will flip this flag to true and if it is true then other threads should not try to acquire the lock.

class SharedResource {

    Lock writeLock

    public Object read() {
        writeLock.acquire()
        doRead()

    }

    public void write(Object toBeWritten) {
        writeLock.acquire()

        doWrite(toBeWritten)

        writeLock.release()
    }

}

Expected is multiple threads should be able to read when no write is going on.

UPDATED 1 :

public class SharedResource {

private Object writeLock = new Object();
private volatile boolean canReadContinue;
private volatile int readCount;

public void write(Object newState) throws InterruptedException {
    synchronized (writeLock) {
        // To make sure no read is going on
        while (readCount > 0) {
            wait();
        }
        System.out.println("Write thread has the lock.");
        doWrite(newState);
    }
}

public Object read() {
    if(canReadContinue) {
        incrementCount();
    } else {
        synchronized (writeLock) {
            System.out.println("Read thread has the lock.");
            canReadContinue = true;
            incrementCount();
        }
    }
    Object result = doRead();
    decrementCount();
    if(readCount == 0) {
        // TODO - release lock and notify

    }

    return result;
}

private synchronized void incrementCount() {
    readCount++;
}

private synchronized void decrementCount() {
    readCount--;
}


private void doWrite(Object newState) {
    // do stuff
}

private Object doRead() {
    return "";
}

}

Now i need a mechanism to release the lock at line "// TODO - release lock and notify", any pointers how to resolve this issue ?

Thanks for the comment Andy but idea is not to use or have minimal use of Java 5 and above concurrency api classes. — user10916892
– user10916892, Commented Jul 1, 2019 at 13:15
@c0der As long as both locks are exclusive locks, there's no benefit because readers would block other readers, which is not requested. — JimmyB
– JimmyB, Commented Jul 1, 2019 at 13:36
lets say JDK 1.4 Why?!?! That was last updated in 2008. Java 8 is already five years old. — Andrew Henle
– Andrew Henle, Commented Jul 1, 2019 at 13:45
This answer contains a JDK 1.4 compatible reentrant lock implementation. Take it as an exercise, to extend it to a read-write lock. — Holger
– Holger, Commented Jul 1, 2019 at 16:27

Stephen C · Accepted Answer · 2019-07-01 14:17:16Z

5

Hints:

You need a mutex; e.g. a primitive object lock.
You need a counter of the number of readers currently holding a logical read lock.
You need a flag to say if a writer is holding a logical write lock.
You hold the mutex if and only you are acquiring or releasing a logical lock. Once you have acquired it, you release the mutex.
You will need to use wait and notify.

Effectively you need to¹ implement a simplified version ReadWriteLock.

^{1 - ... for the purposes of your homework assignment. In a real world program, you should simply use the existing ReadWriteLock class.}

edited Jul 1, 2019 at 14:17

answered Jul 1, 2019 at 13:53

Stephen C

723k95 gold badges849 silver badges1.3k bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Andrew Henle Over a year ago

implement a simplified version ReadWriteLock And that's not really trivial, even for a simplified version. See en.wikipedia.org/wiki/Readers%E2%80%93writers_problem

Stephen C Over a year ago

Did I say it was trivial? :-)

JimmyB Over a year ago

@AndrewHenle I see nowhere in that homework the request to implement a fairness policy, deadlock detection/prevention, priority inheritance or means to prevent starvation of threads. So the task is not "trivial", but doable in ~20-50 lines of code.

Andrew Henle Over a year ago

@JimmyB The title uses the word "optimized": Java optimize read/write a shared resource ....

JimmyB Over a year ago

@AndrewHenle Yeah, and I bet "optimized" means that it's supposed to be an "optimization" of the previous homework in that it now should allow multiple concurrent readers instead of full mutual exclusion.

JimmyB · Accepted Answer · 2019-07-02 14:11:05Z

Answering on your updated code here is some skeleton for you to complete:

public class SharedResource {

  private final Object signal = new Object();
  private boolean writeLocked;
  private int readerCount;

  public void write(final Object newState) throws InterruptedException {

    this.acquireWriteLock();

    try {

      // Now we know that no read and no other write is going on.
      System.out.println("Write thread has the lock.");
      this.doWrite(newState);

    } finally {
      // make sure we release the lock in any case.
      this.realeaseWriteLock();
    }

  }

  private void acquireWriteLock() throws InterruptedException {
    synchronized (this.signal) {

      // Wait until no more readers *and* no writer holds the lock.

      // To do: Insert the condition we need to wait for:

      while (/* condition here! */ ) {
        // To do: Wait for the lock-holding thread(s) to signal that they released their lock(s).
      }

      this.writeLocked = true; // Let others know that the write lock has been taken.

    }
  }

  private void realeaseWriteLock() {
    synchronized (this.signal) {

      this.writeLocked = false;

      // To do: Notify any and all other waiting threads that we released the lock!

    }
  }

  public Object read() {

    // To be done...

  }

  private void acquireReadLock() throws InterruptedException {
    synchronized (this.signal) {

      // Wait until no *writer* holds the lock.
      // To do: Insert condition we need to wait for:

      while (/* condition here! */ ) {
         // To do: Wait for the lock-holding thread(s) to signal that they released their lock(s).

      }

      // Now we know that no writer holds the lock. Acquire (another) read lock:

      this.readerCount++;

    }
  }

  private void releaseReadLock() throws InterruptedException {
    synchronized (this.signal) {

      this.readerCount--;

      // To do: Notify any threads waiting (i.e. writer threads).

      // (In fact only *required* if there are *no* more readers now because that's the only condition any thread will wait on.)

    }
  }

  private void doWrite(final Object newState) {
    // do stuff
  }

  private Object doRead() {
    return "";
  }

}

The main point to understand may be that every attempt to take a lock may have to wait, and that every release of a lock should notify any (potential) waiting threads.

thanks a lot, your "the main point to ..." has cleared the way, i will mark it answered shortly after i am done a bit of experimenting. One question so lets say last reader thread is done reading and about to release the lock and in the mean time a new writer and reader thread comes in, so at this point both will compete to acquire the lock, correct ?

JimmyB · Accepted Answer · 2019-07-02 14:15:26Z

0

Further i am thinking to use a boolean flag e.g. canReadContinue

You're on the right track. But remember that any number of threads could concurrently perform their read accesses and that the write access can only be done if no other thread is currently reading or writing.

So you need to keep track of how many readers are currently holding the lock, and every reader must make sure to release the lock when it's done. Only if & when 0 readers (and 0 writers) hold the lock, a writer may proceed; and only if & when 0 writers hold the lock, any reader may proceed.

edited Jul 2, 2019 at 14:15

answered Jul 1, 2019 at 13:39

JimmyB

12.8k2 gold badges33 silver badges47 bronze badges

Collectives™ on Stack Overflow

Java optimized read/write a shared resource/memory location without Atomic API e.g. AtomicInteger

3 Answers 3

5 Comments

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

5 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related