JUC——线程同步锁（ReentrantReadWriteLock读写锁）
读写锁简介
所谓的读写锁值得是两把锁，在进行数据写入的时候有一个把“写锁”，而在进行数据读取的时候有一把“读锁”。
写锁会实现线程安全同步处理操作，而读锁可以被多个对象读取获取。
读写锁：ReadWriteLock
- 读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由JVM自己控制的。
- ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁（多个线程可以同时读），一个是写锁（单个线程写）。
- ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock，而WriteLock则是完全的互斥。这一特性最为重要，因为对于高读取频率而相对较低写入的数据结构，使用此类锁同步机制则可以提高并发量。
ReadWriteLock接口定义
package java.util.concurrent.locks; public interface ReadWriteLock { Lock readLock(); //读锁 Lock writeLock(); //写锁 }
ReentrantReadWriteLock类定义
package java.util.concurrent.locks; public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable
ReentrantReadWriteLock类结构
小例子:银行存款简单实现
编写一个银行存款的程序，现在有10个人向银行账户存款，存放的一定要采用独占锁（写锁），而在读取的时候所有的线程都可以读取，应该使用共享锁也就是写锁。
在ReadWriteLock接口里面可以发现有两个方法可以获得锁：
- 获得写锁：public Lock writeLock();
- 获得读锁：public Lock readLock();
范例：利用读写锁操作实现存款与查看
package so.strong.mall.concurrent; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class BankDemo { public static void main(String[] args) { final Account account = new Account("iTermis", 15.0); final double[] money = new double[]{5.0, 300.0, 5000.0, 50000.0, 1000.0}; //准备要存入的金额 final int len = money.length; for (int i = 0; i < 2; i++) { //设置两个写线程 new Thread(new Runnable() { @Override public void run() { for (int j = 0; j < len; j++) { account.saveMoney(money[j]); } } }, "存款用户-" + i).start(); } for (int i = 0; i < 10; i++) { //设置10个读线程 new Thread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + "查账，账户名: " + account.getName() + ",资产总额: " + account.loadMoney()); } }, "收款人iTermis-" + i).start(); } } } class Account { private String name; //开户名 private double asset = 10.0; //银行资产 private ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); //读写分离 public Account(String name, double asset) { this.name = name; this.asset = asset; } //存款处理 public boolean saveMoney(double money) { this.readWriteLock.writeLock().lock(); //对写入数据进行锁定处理 try { System.out.println("【(" + Thread.currentThread().getName() + ")存款-BEFORE】存款金额：" + money); TimeUnit.SECONDS.sleep(1); if (money > 0.0) { this.asset += money; return true; //存款成功 } } catch (Exception e) { e.printStackTrace(); } finally { System.out.println("【(" + Thread.currentThread().getName() + ")存款-AFTER】存款金额：" + getAsset()); this.readWriteLock.writeLock().unlock(); //进行解锁处理 } return false; } //返回当前的资金 public double loadMoney() { this.readWriteLock.readLock().lock(); try { return this.getAsset(); } finally { this.readWriteLock.readLock().unlock(); } } public String getName() { return name; } private double getAsset() { return asset; } }
【(存款用户-0)存款-BEFORE】存款金额：5.0 【(存款用户-0)存款-AFTER】存款金额：20.0 【(存款用户-0)存款-BEFORE】存款金额：300.0 【(存款用户-0)存款-AFTER】存款金额：320.0 【(存款用户-0)存款-BEFORE】存款金额：5000.0 【(存款用户-0)存款-AFTER】存款金额：5320.0 【(存款用户-0)存款-BEFORE】存款金额：50000.0 【(存款用户-0)存款-AFTER】存款金额：55320.0 【(存款用户-0)存款-BEFORE】存款金额：1000.0 【(存款用户-0)存款-AFTER】存款金额：56320.0 【(存款用户-1)存款-BEFORE】存款金额：5.0 【(存款用户-1)存款-AFTER】存款金额：56325.0 【(存款用户-1)存款-BEFORE】存款金额：300.0 【(存款用户-1)存款-AFTER】存款金额：56625.0 【(存款用户-1)存款-BEFORE】存款金额：5000.0 【(存款用户-1)存款-AFTER】存款金额：61625.0 【(存款用户-1)存款-BEFORE】存款金额：50000.0 【(存款用户-1)存款-AFTER】存款金额：111625.0 【(存款用户-1)存款-BEFORE】存款金额：1000.0 【(存款用户-1)存款-AFTER】存款金额：112625.0 收款人iTermis-0查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-3查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-6查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-1查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-9查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-2查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-8查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-7查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-5查账，账户名: iTermis,资产总额: 112625.0 收款人iTermis-4查账，账户名: iTermis,资产总额: 112625.0
独占锁处理的速度很慢，但是可以保证线程数据的安全性，而共享锁处理速度快，是对多个线程进行的锁处理机制。
ps:这个读写的处理关系是重要类集ConcurrentHashMap的核心实现思想，当然这是后话。
