# 读写锁类ReadWriteLock #

功能：

    分为读锁和写锁，
    多个读锁不互斥，
    读锁与写锁互斥，
    写锁与写锁互斥，
    JVM自动控制

案例：
package Lock;

    import java.util.Random;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;

    import javax.sound.midi.Soundbank;
    //读写锁案例
    public class InOuWork {

        public static void main(String[] args) {
            final Work work = new Work();
            for (int i = 0; i < 3; i++) {
                new Thread(new Runnable() {
                    public void run() {
                        while (true) {
                            work.get();
                        }

                    }
                }).start();

                new Thread(new Runnable() {
                    public void run() {
                        while (true) {
                            work.put(new Random().nextInt(10000));
                        }

                    }
                }).start();
            }
        }

    }

    class Work {

        private Object data = null;

        ReadWriteLock rwl = new ReentrantReadWriteLock();
        public void get() {
            rwl.readLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + "我开始读了");
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "我读到了" + data);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                rwl.readLock().unlock();
            }
        }

        public void put(Object data) {

            rwl.writeLock().lock();

            try {
                System.out.println(Thread.currentThread().getName() + "我开始写了");
                Thread.sleep(1000);
                this.data = data;
                System.out.println(Thread.currentThread().getName() + "我写完了" + data);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                rwl.writeLock().unlock();
            }
        }

    }

缓存案例：
package Lock;

    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;

    public class CacheReadWriteLockDemo {

        private Map<Integer, Object> map = new LinkedHashMap<>();
        private ReadWriteLock rwl = new ReentrantReadWriteLock();

        public Object get(String id) {

            //多个线程用读锁，不冲突，效率快
            rwl.readLock().lock();
            Object value = null;
            try {
                value = map.get(id);
                if (value == null) {
                    //假如没有数据，则放读锁
                    rwl.readLock().unlock();
                    //上写锁
                    rwl.writeLock().lock();
                    try {
                        //到这里万一多个线程进来了，会再次对第一个线程写入的数据进行修改，所以要加一条if
                        if (value == null) {
                            // 访问数据库
                            value = new Object();// session.get(id,value.getClass());
                        }
                    } finally {
                        rwl.writeLock().unlock();
                    }
                    //恢复读锁状态
                    rwl.readLock().lock();
                }
            } finally {
                rwl.readLock().unlock();
            }

            return value;
        }

    }