Lock读写锁技术的妙用

1.面试题1：三个线程读，三个线程写同一个数据

public class ReadWriteLockTest {

    public static void main(String[] args) {
        final Queue3 q3 = new Queue3();
        for(int i=0;i<3;i++){
            //3个读线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        q3.get();
                    }
                }
            }).start();
            //3个写线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    q3.set(new Random().nextInt(10000));
                }
            }).start();
        }
    }
}

class Queue3{
    private Object data = null; //共享数据，只能有一个线程能写该数据，但可以有多个线程同时读
    ReadWriteLock lock = new ReentrantReadWriteLock();
    public void get(){
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName()+" be ready to read data!");
            Thread.sleep((long)(Math.random()*1000));
            System.out.println(Thread.currentThread().getName()+" have read data: "+data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.readLock().unlock();
        }
    }
    public void set(Object data){
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName()+" be ready to write data!");
            Thread.sleep((long)(Math.random()*1000));
            this.data = data;
            System.out.println(Thread.currentThread().getName()+" hava write data: "+data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.writeLock().unlock();
        }

    }

}

2.

　　Hibernate中两者的区别

　　① User user = session.load(id,User.class);

　　② User user = session.get(id,User.class);

其中②直接从数据库查询，如果查询为空，user为null

其中①在查询时，无论数据路有没有都会得到：User$Proxy 代理类，是一个缓存的User

如果实际的realUser为空则查询数据库，如果从数据库查询出的为空，抛异常，如果不为空

直接返回realUser.getName()　　

User$Proxy extends User{
       private Integer id = id;
       User realUser = null;   
　　　　getName(){
　　　　　　　　if(realUser == null){
　　　　　　　　　　realUser = session.get(id);
　　　　　　　　　　if(realUser == null) 
　　　　　　　　　　throw exception //抛异常
　　　　　　　　}
　　　　　　return realUser.getName();
　　　　}
}

3.javaAPI 上的一段代码：

 Sample usages. Here is a code sketch showing how to exploit reentrancy to perform lock downgrading after updating a cache (exception handling is elided for simplicity): 

  class CachedData {
    Object data;
    volatile boolean cacheValid;
    ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {  //处理数据
      rwl.readLock().lock();  //多个线程并发读，不冲突，只需要上一个读锁
      if (!cacheValid) {   //检查缓存中有没有数据 if中的代码好比第一次获取数据
         // Must release read lock before acquiring write lock
         rwl.readLock().unlock(); //如果一个线程发现没有数据，释放读锁，获取写锁
         rwl.writeLock().lock();
         // Recheck state because another thread might have acquired
         //   write lock and changed state before we did.
         if (!cacheValid) {
           data = ...   //实际的写数据逻辑
           cacheValid = true;  //缓存标志改为true，表示有缓存数据了
         }
         // Downgrade by acquiring read lock before releasing write lock
         rwl.readLock().lock();
         rwl.writeLock().unlock(); // Unlock write, still hold read
      }

      use(data);  //使用数据
      rwl.readLock().unlock();
    }
  }

4.面试题：设计一个缓存系统

 public class CacheDemo {

     private Map<String,Object> cache = new HashMap<>();
     public static void main(String[] args) {

     }

     private ReadWriteLock rwl = new ReentrantReadWriteLock();
     public Object getData(String key){
         rwl.readLock().lock();  //获取读锁
         Object value = null;
         try {
             value = cache.get(key);
             if(value == null){
                 rwl.readLock().unlock();
                 rwl.writeLock().lock();
                 try {
                     if(value == null){
                         value = "aaa"; //实际是去数据库查询
                     }
                 } finally{
                     rwl.writeLock().unlock();
                 }
                 rwl.readLock().lock();
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             rwl.readLock().unlock();  //释放读锁
         }
         return value;
     }

 }