寻找合适的同步机制

Question

假设我有以下（伪）代码：class Cache {    Entry addIfMissing(String data) {        // omitted for brevity    }    void evictOldEntries() {        // omitted for brevity    }}class Program {    private Cache cache = new Cache();    doWork() { // called from multiple threads        var entry = cache.addIfMissing("omitted for brevity");        // work with entry    }    static {        Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {            cache.evictOldEntries();        }, 10, 10, TimeUnit.MINUTES);    }}我想确保在该evictOldEntries方法运行时程序中的所有其他线程都必须等待它完成。在这种情况下哪种同步机制合适？

Answer 1

你需要的是这样的：

class Cache {

    final ReentrantLock lock;

    public Cache { lock = new ReentrantLock(); }

    Entry addIfMissing(String data) {

        lock.lock();

        try {

            // Add data here

        }

        finally {

            lock.unlock();

        }

    }

    void evictOldEntries() {

        if (lock.tryLock()) {

           try {

              // Evict old entries

           }

           finally {

              lock.unlock();

           }

        }

    }

}

Answer 2

由于您的代码示例和确切要求有点不清楚，因此在这里有点自由。但是这样的事情可能行得通吗？ConcurrentHashMap使用细粒度锁定，因此可以最大限度地减少将条目插入缓存时的瓶颈。逐出线程甚至可以与插入线程同时运行。

class Cache<String, CacheEntry> {

    ConcurrentHashMap<String, CacheEntry> map = new ConcurrentHashMap<String, CacheEntry>();

    Entry addIfMissing(String data) {

        map.computeIfAbsent(...);

    }

    void evictOldEntries() {

        Iterator<Map.Entry<String, CacheEntry>> iterator = map.entrySet().iterator();

        while (iterator.hasNext()) {

            CacheEntry entry = iterator.next().getValue();

            if (shouldEvict(entry)) {

                iterator.remove();

            }

        }

    }

}

Answer 3

我认为ReentrantReadWriteLock正是我所需要的：

class Program {

    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void doWork() { // called from multiple threads

        rwl.readLock().lock();

        try {

            var entry = cache.addIfMissing("omitted for brevity");

            // work with entry

        } finally {

            rwl.readLock().unlock();

        }

    }

    static {

        Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {

            rwl.writeLock().lock();

            try {

                cache.evictOldEntries();

            } finally {

                rwl.writeLock().unlock();

            }

        }, 10, 10, TimeUnit.MINUTES);

    }

}

这样一旦获得 writeLock 就doWork必须阻塞，反之亦然。