（二）线程同步_5---使用read/write锁同步数据

使用read/write锁同步数据

在同步机制中，一个显著的改进就是提供了ReadWriteLock接口和其实现类ReentrantReadWriteLock，该类有一对互斥锁(mutual exclusion lock)，一个是read lock,一个是write lock，在同一时刻可以有多个读线程或者在同一时刻只能有一个写线程；当一个写线程正在执行，所有的读线程都将被阻塞，因为读Lock和写Lock是一对互斥的锁；

ReadWriteLock接口中哦那个有两个方法：

• Lock readLock();
• Lock writeLock();

ReentrantReadWriteLock是该接口的唯一实现类；

下面一个例子是读写一个价格信息

动手实现

（1）创建价格信息类

public class PricesInfo {
    private double priceA;
    private double priceB;

    private ReadWriteLock lock=new ReentrantReadWriteLock();

    public PricesInfo() {
        this(1.0, 2.0);
    }
    public PricesInfo(double priceA, double priceB) {
        this.priceA = priceA;
        this.priceB = priceB;
    }

    public double getPriceA() {
        lock.readLock().lock();
        System.out.printf("%s: PriceA readLock: lock\n",Thread.currentThread().getName());
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        double value=priceA;
        System.out.printf("%s: PriceA readLock: unlock\n",Thread.currentThread().getName());
        lock.readLock().unlock();

        return value;
    }

    public double getPriceB() {
        lock.readLock().lock();
        double value=priceB;
        lock.readLock().unlock();
        return value;
    }

    public void setPrices(double priceA, double priceB) {
        lock.writeLock().lock();
        System.out.printf("%s :Writer locked.\n",Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.priceA=priceA;
        this.priceB=priceB;
        lock.writeLock().unlock();
        System.out.printf("%s :Writer unlock.\n", Thread.currentThread().getName());
    }
}

（2）创建读线程

public class Reader implements Runnable{
    private PricesInfo pricesInfo;

    public Reader(PricesInfo pricesInfo) {
        this.pricesInfo = pricesInfo;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.printf("%s: Price B: %f\n",
                    Thread.currentThread().getName(),pricesInfo.getPriceB());
            System.out.printf("%s: Price A: %f\n",
                    Thread.currentThread().getName(),pricesInfo.getPriceA());
        }
    }
}

（3）创建写线程

public class Writer implements Runnable {
    private PricesInfo pricesInfo;

    public Writer(PricesInfo pricesInfo) {
        this.pricesInfo = pricesInfo;
    }

    @Override
    public void run() {
        for (int i=0; i<3; i++) {
            System.out.printf("Writer: Attempt to modify the prices.\n");
            pricesInfo.setPrices(Math.random() * 10, Math.random() * 8);
            System.out.printf("Writer: Prices have been modified.\n");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

通过观察输出可以看出：

• 当没有出现写线程时，多个读线程之间互不相干，正常读取；
• 只有当读线程都释放了锁，写线程才能执行，并且同一时刻只能执行一个；
• 当写线程执行时，读线程都将阻塞；

要点

ReadWriteLock包含一对互斥锁，当Read Lock被线程占有时，Write Lock被阻塞；反之亦然；读线程可以有多个；