Best practice for ConcurrentHashMap use?

Question

Hi All, would the following be considered "best practice", or is there a better way of doing the same thing? The requirement is to have a single unique "Handler" object for each Key:
public class HandlerManager {
    private Object lock = new Object();
    private Map<Key,Handler> map = new ConcurrentHashMap<Key,Handler>();
    public Handler getHandler(Key key) {
        Handler handler = map.get(key);
        if (handler == null) {
            synchronized(lock) {
                handler = map.get(key);
                if (handler == null) {
                    handler = new Handler();
                    map.put(key, handler);
        return handler;
}Clearly this is the old "double-checked-locking" pattern which didn't work until 1.5 and now only works with volatiles. I believe I will get away with it because I'm using a ConcurrentHashMap.
Any opinions? is there a better pattern?
Thanks,
Huw

Answer 1

My personal choice would be to use the reliable "single-checked-locking" pattern:
    public Handler getHandler(Key key) {
        synchronized(lock) {
            Handler handler = map.get(key);
            if (handler == null) {
                handler = new Handler();
                map.put(key, handler);
            return handler;
    }But I'm afraid the Politically Correct way of doing it nowadays looks as ugly as this:
class HandlerManager {
    private Map<Key,Handler> map = new HashMap<Key,Handler>();
    private final Lock readLock;
    private final Lock writeLock;
    public HandlerManager() {
        ReadWriteLock lock = new ReentrantReadWriteLock();
        readLock = lock.readLock();
        writeLock = lock.writeLock();
    public Handler getHandler(Key key) {
        Handler handler = null;
        readLock.lock();
        try {
            handler = map.get(key);
        } finally {
            readLock.unlock();
        if (handler == null) {
            writeLock.lock();
            try {
                handler = map.get(key);
                if (handler == null) {
                    handler = new Handler();
                    map.put(key, handler);
            finally {
                writeLock.unlock();
        return handler;
}