线程同步：读写锁（四）

并发编程中有一个典型的问题是生产者-消费者（Producer-Consumer）问题。我们有一个数据缓冲区，一个或者多个生产者将数据存入这个缓冲区，一个或者多个数据消费者将数据从缓冲区中取走。

使用synchronized关键字

只是用synchronized关键字会有诸多限制。如果缓冲区是满的，生产者不能再放入新的数据，如果缓冲区是空的，消费者不能取到数据。
对于这些场景java在Object类中提供了wait()、notify()、notifyAll()方法

/** * @Desciption 缓冲区 *  * @Author SuFH */public class EventStorage {    private int maxSize;    private LinkedList<Long> storage;    public EventStorage(int max) {        //初始化缓冲区        this.maxSize = max;        this.storage = new LinkedList<Long>();    }    public synchronized void set() {        while (storage.size() == maxSize) {            try {                wait();//挂起当前同步代码块            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }        storage.add(System.currentTimeMillis());        System.out.printf("Set: %d\n", storage.size());        // notify();//唤醒一个正在等待该对象的线程，但需要确定不会造成死锁        notifyAll();// 唤醒所有正在等待该对象的线程。    }    public synchronized void get() {        while (storage.size() == 0) {            try {                wait();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }        System.out.printf("Get: %d : %s\n", storage.size(), storage.poll());        notifyAll();    }}

执行：

public class Test {    public static void main(String[] args) {        EventStorage storage = new EventStorage(10);        Producer producer = new Producer(storage);        Thread thread = new Thread(producer);        Consumer consumer = new Consumer(storage);        Thread thread2 = new Thread(consumer);        thread.start();        thread2.start();    }}class Producer implements Runnable {    private EventStorage storage;    public Producer(EventStorage storage) {        super();        this.storage = storage;    }    @Override    public void run() {        // TODO Auto-generated method stub        for (int i = 0; i < 100; i++) {            this.storage.set();            System.out.println("Producer---"+i);        }    }}class Consumer implements Runnable {    private EventStorage storage;    public Consumer(EventStorage storage) {        super();        this.storage = storage;    }    @Override    public void run() {        // TODO Auto-generated method stub        for (int i = 0; i < 100; i++) {            this.storage.get();            System.out.println("Consumer---"+i);        }    }}

数据存储的EventStorage类中的set()和get()。
set()方法检查存储列表storage是否还有空间，如果满了，调用wait()挂起线程释放控制这个代码块的对象，等待空余空间出现。该代码块的唤醒却决于其他线程调用当前对象的notifyAll()唤醒等待线程来竞争锁。
get()与之不同之处在于条件是判别空间中无数据则挂起。

使用ReadWriteLock接口

ReadWriteLock与它的唯一实现类ReentrantReadWriteLock。这个类有两个锁分别是读操作锁与写操作锁。其中读操作锁允许多个线程同时访问，但是写操作锁至允许一个线程进行访问，并且在进行写操作时，不能进行读操作

/** * @Desciption 缓冲区 *  * @Author SuFH */public class PricesInfo {    private double prices1;    private double prices2;    private ReadWriteLock lock;    public PricesInfo() {        this.prices1 = 0.1;        this.prices2 = 0.2;        this.lock = new ReentrantReadWriteLock();    }    /**读操作     * @return prices1     */    public double getPrices1() {        lock.readLock().lock();        double value=prices1;        lock.readLock().unlock();        return value;    }    /**读操作     * @return prices2     */    public double getPrices2() {        lock.readLock().lock();        double value=prices2;        lock.readLock().unlock();        return value;    }    /**写操作     * @param prices1     * @param prices2     */    public void setPrices(double prices1, double prices2) {        lock.writeLock().lock();        this.prices1 = prices1;        this.prices2 = prices2;        lock.writeLock().unlock();    }}

执行：

public class Test {    public static void main(String[] args) {        PricesInfo info = new PricesInfo();        Read[] reads = new Read[5];        Thread[] thread = new Thread[5];        for (int i = 0; i < 5; i++) {            reads[i] = new Read(info);            thread[i]=new Thread(reads[i]);        }        Writer writer=new Writer(info);        Thread thread2=new Thread(writer);        for (int i = 0; i < 5; i++) {            thread[i].start();        }        thread2.start();    }}class Read implements Runnable {    private PricesInfo info;    public Read(PricesInfo info) {        // TODO Auto-generated constructor stub        this.info = info;    }    @Override    public void run() {        // TODO Auto-generated method stub        for (int i = 0; i < 10; i++) {            System.out.printf("%s Price 1: %f\n", Thread.currentThread().getName(), this.info.getPrices1());            System.out.printf("%s Price 2: %f\n", Thread.currentThread().getName(), this.info.getPrices2());        }    }}class Writer implements Runnable {    private PricesInfo info;    public Writer(PricesInfo info) {        this.info = info;    }    @Override    public void run() {        // TODO Auto-generated method stub        for (int i = 0; i < 3; i++) {            System.out.println("Writer: Attempt to modify the price.");            this.info.setPrices(Math.random()*10,Math.random()*5);            System.out.println("Writer: Prices have been modfied.");            try {                Thread.sleep(2);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }    }}