按值而不是按对象同步

Question

我实现了一个简单的锁定解决方案，它为一个值而不是对象创建一个锁，并且想了解专家对可能的性能或安全缺陷的看法。 这个想法是使用它来更新帐户余额，获取唯一帐号的锁定。

这是一个实现：

import java.util.*;

public class Mutex<T> {

    private final Set<T> set = new HashSet();

    public synchronized Lock acquireLock(
            T value
            ) throws InterruptedException {
        while(!set.add(value)) {
            this.wait();
        }
        return new Lock(value);
    }

    public class Lock {

        private final T value;

        public Lock(T value) {
            this.value = value;
        }

        public T getValue() {
            return value;
        }

        public void release() {
            synchronized(Mutex.this) {
                set.remove(value);
                Mutex.this.notifyAll();
            }
        }
    }
}

以下是检查可操作性的示例用法：

public class Test {

    private Mutex mutex = new Mutex();

    public static void main(String[] args) {
        Test test = new Test();
        Thread t1 = new Thread(() -> {
            try {
                test.test("SameValue");
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        });
        t1.setName("Thread 1");
        Thread t2 = new Thread(() -> {
            try {
                test.test("SameValue");
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        });
        t2.setName("Thread 2");

        t1.start();
        t2.start();
    }

    public void test(String value)
            throws
            InterruptedException {
        Lock lock = mutex.acquireLock(value);
        try {
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName());
        } finally {
            lock.release();
        }
    }
}

Answer 1

关于您的实施，

我会使用 Set 而不是 List 来保存您的值（我假设这些值具有适当的等号/哈希码以使其有意义）： List#contains 方法在 O(n) 中，如果您同时使用了很多 IBAN。

另外，您应该避免使用synchronize(this)（与方法上的同步关键字相同）。

为了解决你的问题，我使用了这样的东西：

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Locks<T> {

    private final Lock lock = new ReentrantLock();

    //a Bimap from guava might be better here if you have the dependency
    //in your project
    private final Map<Reference<?>, T> valuePerReference = new HashMap<>();
    private final Map<T, Reference<Lock>> locks = new HashMap<>();

    private final ReferenceQueue<Lock> lockReferenceQueue = new ReferenceQueue<>();

    public Locks() {
        final Thread cleanerThread = new Thread(new Cleaner());
        cleanerThread.setDaemon(true);
        cleanerThread.start();
    }

    /**
     * @param value the value the synchronization must be made on
     * @return a lock that can be used to synchronize block of code.
     */
    public Lock getLock(T value) {
        lock.lock();
        try {
            return getExistingLock(value).orElseGet(() -> createNewLock(value));
        } finally {
            lock.unlock();
        }
    }


    private Optional<Lock> getExistingLock(T value) {
        return Optional.ofNullable(locks.get(value)).map(Reference::get);
    }

    private Lock createNewLock(T value) {
        //I create ReentrantLock here but a Supplier<Lock> could be a parameter of this
        //class to make it more generic. Same remark for SoftReference below.
        final Lock lock = new ReentrantLock();
        final Reference<Lock> reference = new SoftReference<>(lock, lockReferenceQueue);
        this.locks.put(value,reference);
        this.valuePerReference.put(reference,value);
        return lock;
    }


    private void removeLock(Reference<?> reference) {
        lock.lock();
        try {
            final T value = valuePerReference.remove(reference);
            locks.remove(value);
        } finally {
            lock.unlock();
        }
    }


    private class Cleaner implements Runnable {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    final Reference<? extends Lock> garbaged = lockReferenceQueue.remove();
                    removeLock(garbaged);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }

}

然后我像这样使用它：

import java.util.concurrent.locks.Lock;

public class Usage {

    private final Locks<String> locks = new Locks<>();


    public void doSomethind(String iban) {
        final Lock lock = locks.getLock(iban);
        lock.lock();
        try {
            //.. do something with your iban
        } finally {
            lock.unlock();
        }
    }
}

虽然它使用 ReentrantLock，但代码可以很容易地修改为例如 ReadWriteLock。