使用Java 8和Lambda简化ReadWriteLock

考虑到旧版Java代码，无论您在哪里看，带有lambda表达式的Java 8绝对可以提高质量和可读性。 今天，让我们看一下ReadWriteLock以及如何使它使用起来更简单。 假设我们有一个称为Buffer的类，该类可以记住队列中的最后几条消息，对旧消息进行计数并丢弃。 实现非常简单：

public class Buffer {
 
    private final int capacity;
    private final Deque<String> recent;
    private int discarded;
 
    public Buffer(int capacity) {
        this.capacity = capacity;
        this.recent = new ArrayDeque<>(capacity);
    }
 
    public void putItem(String item) {
        while (recent.size() >= capacity) {
            recent.removeFirst();
            ++discarded;
        }
        recent.addLast(item);
    }
 
    public List<String> getRecent() {
        final ArrayList<String> result = new ArrayList<>();
        result.addAll(recent);
        return result;
    }
 
    public int getDiscardedCount() {
        return discarded;
    }
 
    public int getTotal() {
        return discarded + recent.size();
    }
 
    public void flush() {
        discarded += recent.size();
        recent.clear();
    }
 
}

现在我们可以putItem() ，但是内部recent队列将仅保留最后一个capacity元素。 但是，它也记住必须丢弃多少项以避免内存泄漏。 该类工作正常，但仅在单线程环境中有效。 我们使用不是线程安全的ArrayDeque和非同步的int 。 尽管对int读写是原子的，但不能保证更改在不同线程中可见。 同样，即使我们将线程安全的BlockingDeque与AtomicInteger一起使用，我们仍然处于竞争状态的危险中，因为这两个变量彼此不同步。

一种方法是synchronize所有方法 ，但这似乎很严格。 此外，我们怀疑读取的数量大大超过写入的数量。 在这种情况下， ReadWriteLock是绝佳的选择。 它实际上包括两个锁-一个用于读取，一个用于写入。 实际上，它们都为同一把锁竞争，而同一把锁可以同时由一个作者或多个读者获得。 因此，当没有人在写并且只有写者偶尔阻塞所有读者时，我们可以进行并发读取。 使用synchronized将始终阻止所有其他对象，无论他们做什么。 ReadWriteLock的可悲部分是它引入了许多样板。 您必须显式打开一个锁，并记住在finally块中对其进行unlock() 。 我们的实现变得难以阅读：

public class Buffer {
 
    private final int capacity;
    private final Deque<String> recent;
    private int discarded;
 
    private final Lock readLock;
    private final Lock writeLock;
 
 
    public Buffer(int capacity) {
        this.capacity = capacity;
        recent = new ArrayDeque<>(capacity);
        final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        readLock = rwLock.readLock();
        writeLock = rwLock.writeLock();
    }
 
    public void putItem(String item) {
        writeLock.lock();
        try {
            while (recent.size() >= capacity) {
                recent.removeFirst();
                ++discarded;
            }
            recent.addLast(item);
        } finally {
            writeLock.unlock();
        }
    }
 
    public List<String> getRecent() {
        readLock.lock();
        try {
            final ArrayList<String> result = new ArrayList<>();
            result.addAll(recent);
            return result;
        } finally {
            readLock.unlock();
}
 
    public int getDiscardedCount() {
        readLock.lock();
        try {
            return discarded;
        } finally {
            readLock.unlock();
        }
    }
 
    public int getTotal() {
        readLock.lock();
        try {
            return discarded + recent.size();
        } finally {
            readLock.unlock();
        }
    }
 
    public void flush() {
        writeLock.lock();
        try {
            discarded += recent.size();
            recent.clear();
        } finally {
            writeLock.unlock();
        }
    }
 
}

这是在八月8日之前完成的方式。有效，安全且丑陋。 但是，使用lambda表达式，我们可以将横切关注点包装在这样的实用程序类中：

public class FunctionalReadWriteLock {
 
    private final Lock readLock;
    private final Lock writeLock;
 
    public FunctionalReadWriteLock() {
        this(new ReentrantReadWriteLock());
    }
 
    public FunctionalReadWriteLock(ReadWriteLock lock) {
        readLock = lock.readLock();
        writeLock = lock.writeLock();
    }
 
    public <T> T read(Supplier<T> block) {
        readLock.lock();
        try {
            return block.get();
        } finally {
            readLock.unlock();
        }
    }
 
    public void read(Runnable block) {
        readLock.lock();
        try {
            block.run();
        } finally {
            readLock.unlock();
        }
    }
 
    public <T> T write(Supplier<T> block) {
        writeLock.lock();
        try {
            return block.get();
        } finally {
            writeLock.unlock();
        }
public void write(Runnable block) {
        writeLock.lock();
        try {
            block.run();
        } finally {
            writeLock.unlock();
        }
    }
 
}

如您所见，我们包装了ReadWriteLock并提供了一组可使用的实用程序方法。 原则上，我们希望传递Runnable或Supplier<T> （具有单个T get()方法的接口），并确保调用它时已被适当的锁包围。 我们可以编写完全相同的包装器类，而无需使用lambda，但是使用它们可以大大简化客户端代码：

public class Buffer {
 
    private final int capacity;
    private final Deque<String> recent;
    private int discarded;
 
    private final FunctionalReadWriteLock guard;
 
    public Buffer(int capacity) {
        this.capacity = capacity;
        recent = new ArrayDeque<>(capacity);
        guard = new FunctionalReadWriteLock();
    }
 
    public void putItem(String item) {
        guard.write(() -> {
            while (recent.size() >= capacity) {
                recent.removeFirst();
                ++discarded;
            }
            recent.addLast(item);
        });
    }
 
    public List<String> getRecent() {
        return guard.read(() -> {
            return recent.stream().collect(toList());
        });
    }
 
    public int getDiscardedCount() {
        return guard.read(() -> discarded);
    }
 
    public int getTotal() {
        return guard.read(() -> discarded + recent.size());
    }
 
    public void flush() {
        guard.write(() -> {
            discarded += recent.size();
            recent.clear();
        });
    }
 
}

看看我们如何调用guard.read()和guard.write()传递应该受到保护的代码段？ 看起来很整洁。 顺便说一句，您是否注意到我们如何使用stream()将任何集合转换为任何其他集合（在这里： Deque into List stream() ？ 现在，如果我们提取几个内部方法，则可以使用方法引用来进一步简化lambda：

public void flush() {
    guard.write(this::unsafeFlush);
}
 
private void unsafeFlush() {
    discarded += recent.size();
    recent.clear();
}
 
public List<String> getRecent() {
    return guard.read(this::defensiveCopyOfRecent);
}
 
private List<String> defensiveCopyOfRecent() {
    return recent.stream().collect(toList());
}

这只是利用lambda表达式来改进现有代码和库的众多方法之一。 我们真的很高兴他们终于进入Java语言了，同时已经出现在其他数十种JVM语言中。

翻译自: https://www.javacodegeeks.com/2014/03/simplifying-readwritelock-with-java-8-and-lambdas.html