A Useful StripedLock from GridGain

A pretty cool locking mechanism which we use every now and then at GridGain is concurrent segmented "striped" locks. Sometimes, your objects are constantly recreated, so you can't really attach a mutex to them. For cases like those you can partition the object space into multiple segments (often by object hashcode value) and only acquire the lock on the segment an object belongs to. This way the more segments you have, the more concurrency you have.

Here is a code for our StripedLock that I thought would be good to share:
 

public class StripedLock {
    // Array of underlying locks.
    private final Lock[] locks;
 
    public StripedLock(int concurrencyLevel) {
        locks = new Lock[concurrencyLevel];
 
        for (int i = 0; i < concurrencyLevel; i++)
            locks[i] = new ReentrantLock();
    }
 
    public int concurrencyLevel() {
        return locks.length;
    }
 
    public Lock getLock(int key) {
        return locks[abs(key) % locks.length];
    }
 
    public Lock getLock(long key) {
        return locks[abs((int)(key % locks.length))];
    }
 
    // Account for Math.abs() returning negative value.
    private int abs(int key) {
        return key == Integer.MIN_VALUE ? 0 : Math.abs(key);
    }
 
    public Lock getLock(@Nullable Object o) {
        return o == null ? locks[0] : getLock(o.hashCode());
    }
 
    public void lock(int key) {
        getLock(key).lock();
    }
 
    public void lock(long key) {
        getLock(key).lock();
    }
 
    public void unlock(int key) {
        getLock(key).unlock();
    }
 
    public void unlock(long key) {
        getLock(key).unlock();
    }
 
    public void lock(@Nullable Object o) {
        getLock(o).lock();
    }
 
    public void unlock(@Nullable Object o) {
        getLock(o).unlock();
    }
}