读写锁介绍
现实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那 么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以 应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源， 就不应该允许其他线程对该资源进行读和写的操作了。
针对这种场景，JAVA 的并发包提供了读写锁 ReentrantReadWriteLock， 它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁
1. 线程进入读锁的前提条件：
• 没有其他线程的写锁
• 没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)。
2. 线程进入写锁的前提条件：
• 没有其他线程的读锁
• 没有其他线程的写锁
而读写锁有以下三个重要的特性：
（1）公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。
（2）重进入：读锁和写锁都支持线程重进入。
（3）锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为 读锁。
ReentrantReadWriteLock
1. public class ReentrantReadWriteLock implements ReadWriteLock, 2. java.io.Serializable { 3. /** 4. * 读锁 5. */ 6. private final ReentrantReadWriteLock.ReadLock readerLock; 7. 8. /** 9. * 写锁 10. */ 11. private final ReentrantReadWriteLock.WriteLock writerLock; 12. final Sync sync; 13. 14. /** 15. * 使用默认（非公平）的排序属性创建一个新的 16. * ReentrantReadWriteLock 17. */ 18. public ReentrantReadWriteLock() { 19. this(false); 20. } 21. 22. /** 23. * 使用给定的公平策略创建一个新的 ReentrantReadWriteLock 24. */ 25. public ReentrantReadWriteLock(boolean fair) { 26. sync = fair ? new FairSync() : new NonfairSync(); 27. readerLock = new ReadLock(this); 28. writerLock = new WriteLock(this); 29. 30. 31. } 32. 33. /** 34. * 返回用于写入操作的锁 35. */ 36. public ReentrantReadWriteLock.WriteLock writeLock() { 37. return 38. writerLock; 39. } 40. 41. /** 42. * 返回用于读取操作的锁 43. */ 44. public ReentrantReadWriteLock.ReadLock readLock() { 45. return 46. readerLock; 47. } 48. 49. abstract static class Sync extends AbstractQueuedSynchronizer { 50. } 51. 52. static final class NonfairSync extends Sync { 53. } 54. 55. static final class FairSync extends Sync { 56. } 57. 58. public static class ReadLock implements Lock, java.io.Serializable { 59. } 60. 61. public static class WriteLock implements Lock, java.io.Serializable { 62. } 63. }
可以看到，ReentrantReadWriteLock 实现了 ReadWriteLock 接口， ReadWriteLock 接口定义了获取读锁和写锁的规范，具体需要实现类去实现； 同时其还实现了 Serializable 接口，表示可以进行序列化，在源代码中可以看 到 ReentrantReadWriteLock 实现了自己的序列化逻辑。
入门案例
场景: 使用 ReentrantReadWriteLock 对一个 hashmap 进行读和写操作
1. class MyCache{ 2. //创建map集合 3. private volatile Map<String,Object> map=new HashMap<>(); 4. 5. //创建读写锁对象 6. private ReadWriteLock rw=new ReentrantReadWriteLock(); 7. //放对象 8. public void put(String key,Object value){ 9. rw.writeLock().lock(); 10. try { 11. System.out.println(Thread.currentThread().getName()+"正在进行操作"); 12. TimeUnit.MICROSECONDS.sleep(300); 13. map.put(key,value); 14. System.out.println("操作完成"); 15. } catch (InterruptedException e) { 16. e.printStackTrace(); 17. } finally { 18. rw.writeLock().unlock(); 19. } 20. } 21. //取对象 22. public Object get(String key){ 23. Object result=null; 24. try { 25. rw.readLock().lock(); 26. System.out.println(Thread.currentThread().getName() + "正在取值"); 27. TimeUnit.MICROSECONDS.sleep(300); 28. result=map.get(key); 29. } catch (InterruptedException e) { 30. e.printStackTrace(); 31. }finally { 32. rw.readLock().unlock(); 33. } 34. return result; 35. } 36. }
小结
• 在线程持有读锁的情况下，该线程不能取得写锁(因为获取写锁的时候，如果发 现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有)。
• 在线程持有写锁的情况下，该线程可以继续获取读锁（获取读锁时如果发现写 锁被占用，只有写锁没有被当前线程占用的情况才会获取失败）。
原因: 当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把 获取读锁的线程“升级”为写锁；而对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释 放写锁继续持有读锁，这样一个写锁就“降级”为了读锁。
