Anatomy of Sync

The purpose of most (if not all) synchronizers is to guard some area of the code (critical section) from concurrent access by threads. To do this the following parts are often needed in a synchronizer:

• State
• Access Control
• State changes
• Notification strategy

State

public class Lock{

//state is kept here
  private boolean isLocked = false; 

public synchronized void lock()
throws InterruptedException{
while(isLocked){
      wait();
    }
    isLocked = true;
  }

  ...
}

public class BoundedSemaphore {

//state is kept here
  private int signals = 0;
private int bound   = 0;

public BoundedSemaphore(int upperBound){
this.bound = upperBound;
  }

public synchronized void take() throws InterruptedException{
while(this.signals == bound) wait();
this.signal++;
this.notify();
  }
  ...
}

Access Control

public class Lock{

private boolean isLocked = false;

public synchronized void lock()
throws InterruptedException{
//access condition
    while(isLocked){
      wait();
    }
    isLocked = true;
  }

  ...
}

public class BoundedSemaphore {
private int signals = 0;
private int bound   = 0;

public BoundedSemaphore(int upperBound){
this.bound = upperBound;
  }

public synchronized void take() throws InterruptedException{
//access condition
    while(this.signals == bound) wait();
this.signals++;
this.notify();
  }

public synchronized void release() throws InterruptedException{
//access condition
    while(this.signals == 0) wait();
this.signals--;
this.notify();
  }
}

State Changes

public class Lock{

private boolean isLocked = false;

public synchronized void lock()
throws InterruptedException{
while(isLocked){
      wait();
    }
//state change
    isLocked = true;
  }

public synchronized void unlock(){
//state change
    isLocked = false;
    notify();
  }
}

public class BoundedSemaphore {
private int signals = 0;
private int bound   = 0;

public BoundedSemaphore(int upperBound){
this.bound = upperBound;
  }

public synchronized void take() throws InterruptedException{
while(this.signals == bound) wait();
//state change
    this.signals++;
this.notify();
  }

public synchronized void release() throws InterruptedException{
while(this.signals == 0) wait();
//state change
    this.signals--;
this.notify();
  }
}

Notification Strategy

public class Lock{

private boolean isLocked = false;

public synchronized void lock()
throws InterruptedException{
while(isLocked){
//wait strategy - related to notification strategy
      wait();
    }
    isLocked = true;
  }

public synchronized void unlock(){
    isLocked = false;
    notify(); //notification strategy
  }
}

The pattern of locking is somewhat unusual in that the lock is released and reacquired in the middle of the operation. The state variables that make up the precondition must be guarded by the object's lock, so that they can remain constant while the precondition is tested. But if the precondition does not hold, the lock must be released so another thread can modify the object state otherwise the precondition will never become true. The lock must then be reacquired before testing the precondition again.

 

void blockingAction() throws InterruptedException {
    acquire lock on object state
while (precondition does not hold) {
        release lock
        wait until precondition might hold
        optionally fail if interrupted or timeout expires
        reacquire lock
    }
    perform action
}

Condition

public class ConditionBoundedBuffer<T> {
protected final Lock lock = new ReentrantLock();
// CONDITION PREDICATE: notFull (count < items.length)
    private final Condition notFull    = lock.newCondition();
// CONDITION PREDICATE: notEmpty (count > 0)
    private final Condition notEmpty  = lock.newCondition();
    @GuardedBy("lock")
private final T[] items = (T[]) new Object[BUFFER_SIZE];
    @GuardedBy("lock") private int tail, head, count;

// BLOCKS-UNTIL: notFull
    public void put(T x) throws InterruptedException {
        lock.lock();
try {
while (count == items.length)
                notFull.await();
            items[tail] = x;
if (++tail == items.length)
                tail = 0;
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

// BLOCKS-UNTIL: notEmpty
    public T take() throws InterruptedException {
        lock.lock();
try {
while (count == 0)
                notEmpty.await();
            T x = items[head];
            items[head] = null;
if (++head == items.length)
                head = 0;
            --count;
            notFull.signal();
return x;
        } finally {
            lock.unlock();
        }
    }

}

 

Lock

 

public class SemaphoreOnLock {
private final Lock lock = new ReentrantLock();
// CONDITION PREDICATE: permitsAvailable (permits > 0)
    private final Condition permitsAvailable = lock.newCondition();
    @GuardedBy("lock") private int permits;

    SemaphoreOnLock(int initialPermits) {
        lock.lock();
try {
            permits = initialPermits;
        } finally {
            lock.unlock();
        }
    }

// BLOCKS-UNTIL: permitsAvailable
    public void acquire() throws InterruptedException {
        lock.lock();
try {
while (permits <= 0)
                permitsAvailable.await();
            --permits;
        } finally {
            lock.unlock();
        }
    }

public void release() {
        lock.lock();
try {
            ++permits;
            permitsAvailable.signal();
        } finally {
            lock.unlock();
        }
    }
}

转载于:https://www.cnblogs.com/grep/archive/2012/03/27/2419151.html