Java多线程并发编程 — 读写锁 Reentrant Read Write Lock

Java多线程并发编程 — 读写锁 Reentrant Read Write Lock


ReentrantReadWriteLock 实现 interface ReadWriteLock：


public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();


    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}
所以 ReentrantReadWriteLock 并非是真的一个“锁”，而是一个读锁和写锁的管理器，而真正实现锁功能的是 ReentrantReadWriteLock 的静态内部类 ReadLock 和 WriteLock。ReadLock 和 WriteLock 都是直接实现 interface Lock。


当多线程共享同一个数据源时，为了避免数据上的错乱，我们需要在读数据的时候防止写入操作，在写入的时候也不能进行读操作。怎么实现这一业务？synchronized、ReentrantLock 都可以实现，在读、写操作的方法都加上锁的保护，则可实现读写互斥。但这种做法会使并发大大折扣，例如在某一时间段只有大量读操作并没有写操作，但此时读操作也要进行排队，此时 ReentrantReadWriteLock 的价值就能发挥得淋漓尽致。


ReentrantReadWriteLock 的作用：支持同时多读，读的时候不能写，写的时候不能读。


看看具体的 DEMO1，一个支持多用户的银行账号（夫妻共用）的存款和查询的需求：


1，可多用户同时查询余额（读操作）


2，当有用户在查询余额时（读操作），该账号不能进行存取款操作（写入操作）


3，当有用户在存取款时（写入操作），该账号不能进行查询余额操作（读操作）


具体实现：


public class Test {


    static class User {
        int mID;
        BankAccount mBankAccount;


        public User(int ID, BankAccount bankAccount) {
            mID = ID;
            mBankAccount = bankAccount;
        }


        public void saveMoney(final int cash) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    mBankAccount.saveMoney(mID, cash);
                }
            }).start();
        }


        public void checkBalance() {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    mBankAccount.checkBalance(mID);
                }
            }).start();
        }
    }


    /**
     * 支持多用户的银行账号（夫妻共用）
     */
    static class BankAccount {


        int mBalance;
        ReentrantReadWriteLock mReentrantReadWriteLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.WriteLock mWriteLock = mReentrantReadWriteLock.writeLock();
        ReentrantReadWriteLock.ReadLock mReadLock = mReentrantReadWriteLock.readLock();


        public void saveMoney(int id, int cash) {
            mWriteLock.lock();
            try {
                mBalance = mBalance + cash;
                System.out.println(" 用户 " + id + " 正在进行存钱操作 ");
                Thread.sleep(2000);
                System.out.println(" 用户 " + id + " 存钱完成，存入 " + cash + " 元 ");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                mWriteLock.unlock();
            }
        }


        public void checkBalance(int id) {
            mReadLock.lock();
            try {
                System.out.println(" 用户 " + id + " 正在进行查询余额操作 ");
                Thread.sleep(2000);
                System.out.println(" 余额：" + mBalance);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                mReadLock.unlock();
            }
        }
    }


    public static void main(String[] var0) {
        BankAccount bankAccount = new BankAccount();
        User user1 = new User(1, bankAccount);
        User user2 = new User(2, bankAccount);


        user1.saveMoney(1000000);


        // 同时查询余额
        user1.checkBalance();
        user2.checkBalance();


        // 同时存款
        user1.saveMoney(2000000);
        user2.saveMoney(6000);


        user1.checkBalance();
    }
}
DEMO1 的输出：


用户 1 正在进行存钱操作
用户 1 存钱完成，存入 1000000 元
用户 1 正在进行查询余额操作
用户 2 正在进行查询余额操作
余额：1000000
余额：1000000
用户 1 正在进行存钱操作
用户 1 存钱完成，存入 2000000 元
用户 2 正在进行存钱操作
用户 2 存钱完成，存入 6000 元
用户 1 正在进行查询余额操作
余额：3006000
当两个用户同时查询余额时，可同时进行。


当两个用户同时存款时，不能同时进行，要进行队列排队。


可见，我们可以用 ReentrantReadWriteLock 进行一些读写需要互斥的一些业务上，特别适合在“大量读小量写”的业务，可以增大吞吐率。