Monitors, conditions, readers and writers locks

Question 1

What are monitor locks

Answer 1

only 1 thread can hold a lock
A thread acquires a lock when it starts to hold the lock
releases lock when stops holding lock

Question 2

In Monitor locks what happens when a thread cant immediately acquire a lock?

Answer 2

Spins and repeatedly tests
Blocks and suspends thread and creates new thread
Spin = short time. Blocking = long time

Question 3

How do you create a new condition

Answer 3

Condition = mutex.newCondition();//mutex = lock that its related to

Question 4

how do you make a condition suspend

Answer 4

condition.await()

Question 5

how can you notify threads that a change has occurred in a condition?

Answer 5

signal() or signalAll()

Question 6

Does a thread have to retest condition if awaken and compete for the lock?

Answer 6

yes

Question 7

What is a monitor?

Answer 7

combination of mutual exclusion locks and condition objects

Question 8

What is lost wakeup problem?

Answer 8

1+ threads wait forever without realizing that the property for which they have been waiting has become true

Question 9

enq code for Monitor?

Answer 9

public void enq(T x) {
lock.lock();
try {
while (count == items.length)
isFull.await();
items[tail] = x;
++count;
if (count == 1)
isEmpty.signal();
}
} finally {
lock.unlock();
}
}

Question 10

How to avoid lost wakeup

Answer 10

ensure all processes are signaled
Specify timeout when waiting

Question 11

What is allowed in the CS for reader-writer locks?

Answer 11

either multiple readers or a single writer

Question 12

Reader-writer lock interface

Answer 12

public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}

Question 13

What properties should the interface satisfy for the reader-writer lock?

Answer 13

No thread can acquire write lock while any thread holds either lock or read lock
no thread can acquire read lock while any other thread holds write lock

Question 14

Class code for SimpleReadWriteLock

Answer 14

public class SimpleReadWriteLock implements ReadWriteLock {
boolean writer;
int readers;
Lock lock;
Condition condition;
Lock readLock, writeLock;

Question 15

lock for ReadLock

Answer 15

class ReadLock implements Lock {
public void lock() {
lock.lock();
try {
while (writer)
condition.await();
readers++;
} finally {
lock.unlock();
}

Question 16

unlock for readLock

Answer 16

public void unlock() {
lock.lock();
try {
readers–;
if (readers == 0)
condition.signalAll();
} finally {
lock.unlock();
}

Question 17

lock for writeLock

Answer 17

class WriteLock implements Lock {
public void lock() {
lock.lock();
try {
while (readers > 0)
condition.await();
writer = true;
} finally {
lock.unlock();
}

Question 18

un lock for writeLock

Answer 18

public void unlock() {
writer = false;
condition.signalAll();
}

Question 19

Is the simple readWrite lock fair?

Answer 19

no as long as readers are “added” it can wait

Question 20

FIFOReadWriteLock

Answer 20

public class FIFOReadWriteLock
implements ReadWriteLock {
boolean writer;
int readAcquires, readReleases;
Lock lock;
Condition condition;
Lock readLock, writeLock;

Question 21

FIFOReader lock

Answer 21

class ReadLock implements Lock {
public void lock() {
lock.lock();
try {
while (writer)
condition.await();
readAcquires++;
} finally {
lock.unlock();
}

Question 22

FIFOreader unlock

Answer 22

public void unlock() {
lock.lock();
try {
readReleases++;
if (readAcquires == readReleases)
condition.signalAll();
} finally {
lock.unlock();
}

Question 23

FIFOWrite lock

Answer 23

class WriteLock implements Lock {
public void lock() {
lock.lock();
try {
writer = true;
while (readAcquires !=
readReleases)
condition.await();
} finally {
lock.unlock();
}

Question 24

FIFOWrite unlock

Answer 24

public void unlock() {
writer = false;
condition.signalAll();
}