如何为有意义的相等对象创建线程锁/同步并防止各个线程的并行执行？

Question

private Map<CustomerKey, Customer> customerMap = new ConcurrentHashMap<CustomerKey, Customer>();

public Customer getCustomer(CustomerKey customerKey)
{   
    Customer customer = customerMap.get(customerKey);
    if(null == customer)
    {
        synchronized(this)
        {
            customer = customerMap.get(customerKey); // Added line
            if(null == customer)
            {
                customer = new Customer();
                customerMap.put(customerKey, customer); // Added line
            }
        }
    }
    return customer;
}

This is how we usually do object level locking.

In this example, object level locking is applied irrespective of the value of the customerKey object. So even for different customerKey objects, the particular block will be synchronized. I don't want this behavior.

Instead of "this" variable, if I acquire lock on customerKey object like below,

synchronized(customerKey)

Multiple threads can be passing different customerKey objects but with same value which means they are meaningfully equal (customerKeyThread1.equals(customerKeyThread2)) but not same objects (customerKeyThread1 != customerKeyThread2)

So locking at customerKey object is also not a valid solution.

So I need some logic which provides synchronization for a set of code not only for same object but also for meaningfully equal objects . How can I achieve the same?

Answer 1

Well you made it simpler in such a case (it seems to me), just use ConcurrentHashMap.computeIfAbsent as it is documented with:

the current (existing or computed) value associated with the specified key, or null if the computed value is null.

It also says that:

The entire method invocation is performed atomically....

So you could do:

public Customer getCustomer(CustomerKey customerKey) {
    return customerMap.computeIfAbsent(customerKey, x-> new Customer());
}