top

COMP 402: Production Programming

← Concurrency →

Home — Spring 2012

Today's Menu:

Concurrency Homework Discussion
Tangent: Priority Inversion (local copy)
Tangent: Modeling Concurrent Processes (Introduction to SPIN and Promela, from COMP 607 by Dr. Ian Barland, Dr. Moshe Vardi, and Dr. John Greiner)

Homework Discussion

Bounded Buffer Student Solution

import java.util.*;

public class BoundedBuffer<T> implements IBoundedBuffer<T> {
    final int NUM_BUFFER;
    volatile int count_current_elements = 0;
    Object _lock = new Object();
    ArrayList _buffer=new ArrayList();
  
    public BoundedBuffer(int size) {
        NUM_BUFFER=size;
    }
  
    public void write(T item) throws InterruptedException{
        synchronized(_lock) {
            while(count_current_elements>=NUM_BUFFER){
                try {
                    _lock.wait();
                }
                catch(InterruptedException ie) { /* ignore */ }          
            }
            _buffer.add(item);
            count_current_elements++;
            _lock.notifyAll();
        }
    }      
  
    public T read() throws InterruptedException{
        T value;
        synchronized(_lock) {
      
            while(count_current_elements<=0){
                try {
                    _lock.wait();
                }
                catch(InterruptedException ie) { /* ignore */ }
            }
            value =(T)(_buffer.remove(0));
            count_current_elements--;
            _lock.notifyAll();
        }      
        return value;
    }
}

Comments:

We should use generics whenever you can. That means we should used ArrayList _buffer=new ArrayList(); instead of ArrayList _buffer=new ArrayList(); . That way, _buffer can only contain elements of type T. But this is not related to concurrency. In DrJava, however, we don't want to use "raw" types, i.e. classes where you could specify a type. For all Java collections (ArrayList, LinkedList, HashSet, HashMap, etc.), for example, we want to specify the types they contain.
You really only need to notify when the count goes from 0 to 1 or from NUM_BUFFER to NUM_BUFFER-1. In other cases, the situation will not have changed.

The other solutions were similar. What differed was the use of an array instead of a list (there are no generic arrays), the use of notify() instead of notifyAll(), and item 2 above.

Reader Writer Lock Student Solution 1

import java.util.*;

public class ReaderWriterLock implements IReaderWriterLock {
    volatile int num_activeReader = 0;
    volatile int num_activeWriter = 0;
    volatile int num_waitingReader = 0;
    volatile int num_waitingWriter = 0;
    HashSet<Thread> currentlyReading = new HashSet<Thread>();
    Thread currentlyWriting =new Thread();
    Object _lock = new Object();
  
    public void startRead(){
        if (currentlyReading.contains(Thread.currentThread())) {
            return;
        }
        if (currentlyWriting==Thread.currentThread()) {
            throw new DeadlockException();
        }
        synchronized(_lock) {
            num_waitingReader++;
            while(num_waitingWriter != 0 || num_activeWriter != 0){
                try {
                    _lock.wait();
                }
                catch(InterruptedException ie) { /* ignore */ }
        
            }
            num_waitingReader--;
            num_activeReader++;
            currentlyReading.add(Thread.currentThread());
        }
    }
  
    public void endRead(){
        if (!currentlyReading.contains(Thread.currentThread())) {
            return;
        }
        synchronized(_lock) {
            num_activeReader--;
            currentlyReading.remove(Thread.currentThread());
            if(num_activeReader==0)
                _lock.notifyAll();
        }      
    }
  
    public void startWrite(){
        if (currentlyReading.contains(Thread.currentThread())||currentlyWriting==Thread.currentThread()) {
            throw new DeadlockException();
        }
        synchronized(_lock) {
            num_waitingWriter++;
            while(num_activeWriter != 0 || num_activeReader != 0){
                try {
                    _lock.wait();
                }
                catch(InterruptedException ie) { /* ignore */ }
        
            }
            num_waitingWriter--;
            num_activeWriter++;
            currentlyWriting=Thread.currentThread();
        }
    }
  
  
    public void endWrite(){
        synchronized(_lock) {
            num_activeWriter--;
            currentlyWriting=new Thread();
            _lock.notifyAll();
        }      
    }  
}

Comments:

This may wake up threads that still cannot do anything: If a writer is woken up and gets the lock back first, then all readers and other writers will have to wait.
Since it's nondeterministic which thread gets the lock back first, this solution may be unfair.

Reader Writer Lock Student Solution 2

import java.util.LinkedList;
import java.lang.Exception;

public class ReaderWriterLock {
    private volatile int activeReaders = 0;
    private volatile int waitingReaders = 0;
    private volatile int activeWriters = 0;
    private volatile int waitingWriters = 0;
  
    private final LinkedList _waitQueue = new LinkedList();
    private final LinkedList _threads = new LinkedList();
  
    public synchronized void startRead() {
        if (!(activeReaders > 0 && _threads.contains(Thread.currentThread()))) { //makes sure that a reader is not called twice    
            if (_threads.contains(Thread.currentThread())) 
                throw new DeadlockException();
      
            if (waitingWriters> 0 || activeWriters > 0) {
                waitingReaders++;
                Reader r = new Reader();
                r.waitThread();
            }
        }
        _threads.add(Thread.currentThread());
        waitingReaders--;
        activeReaders++;
    }
  
    public synchronized void endRead(){
        activeReaders--;
        _threads.remove(Thread.currentThread());
        if (activeReaders == 0)
            notifyReaderWriter();
    }
  
    public synchronized void startWrite() {
        if (_threads.contains(Thread.currentThread())) {
            //makes sure that the write is not called twice or else deadlock
            throw new DeadlockException();
        }
    
        if ( activeReaders > 0 || activeWriters > 0 || waitingReaders > 0 || waitingWriters> 0) {
            waitingWriters++;
            Writer w = new Writer();
            w.waitThread(); 
        }
    
        waitingWriters--;
        activeWriters++;
        _threads.add(Thread.currentThread());
    }
  
    public synchronized void endWrite(){
        activeWriters--;    
        _threads.remove(Thread.currentThread());
        notifyReaderWriter();
    }
  
    private synchronized void notifyReaderWriter() {
        while(_waitQueue.size()>0) {
            ReadWrite front = (ReadWrite)_waitQueue.getFirst();
            if(front.name().equals("reader"))
                front.startThread(); // removes front from queue
            if(front.name().equals("writer")) { //front is a writer
                front.startThread();
                break;
            }
        }
    }
  
    public abstract class ReadWrite{
        private volatile boolean wait = true;
        public abstract String name();
    
        public void waitThread() {
            synchronized(ReaderWriterLock.this) {
                wait = true;
                _waitQueue.addLast(this);
                while (wait) {
                    try { 
                        ReaderWriterLock.this.wait(); 
                    }
                    catch (InterruptedException e) {
                    }
                }
            }
        }
    
        public void startThread() {
            synchronized(ReaderWriterLock.this) {
                wait = false;
                _waitQueue.removeFirst(); 
                ReaderWriterLock.this.notifyAll();
            }
        }
    }
  
    public class Reader extends ReadWrite {
        public String name() { return "reader";}
    }
  
    public class Writer extends ReadWrite {
        public String name() {return "writer";}
    }
  
    public static class DeadlockException extends IllegalStateException {
        public DeadlockException() { }
        public DeadlockException(String s) { super(s); }
        public DeadlockException(String s, Throwable t) { super(s,t); }
        public DeadlockException(Throwable t) { super(t); }
    }
}

Comments:

This solution still wakes up every thread, but the order in which we allow threads to continue is determined by a queue, so it is fair.
The occurrences of waitingReaders--; and waitingWriters--; are not in the proper place; they may be executed even when the matching waitingWriters++; and waitingReaders++; are not executed.
The code that wakes up threads is flawed. If readers have been woken up already, a writer should not be woken up. Otherwise, you will have readers and a writer running concurrently. The code should really look like this:

Instructor Solutions

There are other ways to implement the homework, but here are our solutions:

← Concurrency →

URL: http://www.cs.rice.edu/~javaplt/402/12-spring/lectures/conc3/index.shtml