Question

A library I’m writing has a class implementing a two dimensional map and also provides, for efficient reading, smaller maps for the row/column views. So far all methods have been overridden so that any change in the main map are mirrored in the sub maps and vice versa. The problem comes in concurrent operation.

Ideally a removal of an item from the master map will simultaneously remove the item from the respective row and column maps, but this is of course impossible. For example in my put function:

public synchronized Cell put(Duple<Integer, Integer> key, Cell arg1){
    //preprocessing, detecting the row/col, creating row/col if not present yet, etc.
    Cell outcell = super.put(key, arg1);
    rowArr.putPriv(key.getElem2(), arg1);
    colArr.putPriv(key.getElem1(), arg1);
    arg1.assignCell(this, key);
    return outCell;
}

While it is perfectly acceptable for simultaneous reads of the map and even concurrent modification is not an issue (except for the creation/removal of rows/columns which needs remove and put to be synchronized), but The 4 stages of modification (super.put, the row and column puts, and the cell location update) need to be atomic to ensure it’s not possible to read unmatched data.

What are my options? As far as I’ve found from my searching it’s not possible to create an atomic sequence of statements in Java, and synchronisation isn’t going to work unless I synchronise all my functions (which prevents concurrent reads, and I would need locks on multiple items). I know the principles of (but am not particularly practiced in) basic semaphore concepts, but don’t see any simple ways to make a lock-on-write semaphore without massive complexity, particularly if I don’t want to have massive waits for a writing slot. What additional options do I have?

Note: due to the project I’m on I cannot use derivative languages such as groovy but can only use standard Java 1.6u24, without 3rd party libraries.

Answer 1

I’d suggest you not synchronize on entire method put. But synchronize only on on specific cell. In code below, I’ll describe how to do that:

class ConcurrMattr {

    private ConcurrentHashMap<Integer, Lock> locks = 
                    new ConcurrentHashMap<Integer, Lock>();

    public Cell put( CellCoords key, Cell arg1 ) {
        // get or create lock for specific cell (guarantee its uniqueness)
        Lock lock = this.locks.putIfAbsent( coords.hash % 64, new ReentrantLock() );
        // 64 threads may concurrently modify different cells of matrix

        try {
            // lock only specific cell
            lock.lock();

            // do all you need with cell

            return ...;

        } finally {
            // unlock cell
            lock.unlock();
        }
    }    
}


// Immutable class to represent cell coordinates
class CellCoords {    
    public final int x;
    public final int y;
    public final int hash;

    public CellCoords( int x, int y ) {
        this.x = x;
        this.y = y;
        this.hash = this.calcHash();
    }

    private int calcHash() {
        int result = 31 + this.x;
        return 31 * result + this.y;
    }
}

So you may synchronize read/write methods on specific cell, while other part of matrix will be accessible to other threads.

Look at javadoc for ConcurrentHashMap and for Lock

P.S.
You may notice, that CellCoords field hash has type int. To avoid growth of locks map size till 2^31, you have to limit range of hashes. For example: (coords.hash % 64) – allows only 64 concurrent threads to work with entire matrix.

P.P.S. Might be interesting article for you: http://www.ibm.com/developerworks/java/library/j-jtp08223/