多线程程序设计学习（7）read-write lock pattern

Read-Write Lock Pattern【读写】
一:Read-Write Lock Pattern的参与者
--->读写锁
--->数据(共享资源)
--->读线程
--->写线程

二Read-Write Lock Pattern模式什么时候使用
--->
* 为了多线线程环境下保护数据安全，我们必须避免的冲突
* 一个线程读取，另一个线程写入的read-write conflick
* 一个线程写入，另一个线程写入的write-write conflick
* 一个线程读取，另一个线程也在读取不会产生冲突
*
* 当线程想要获取读取锁定时：
* -->已经有线程在执行写入，则等待。不等待，则发生read-write conflick
* -->已经有线程在读取，则不需要等待。不存在read-read conflick
*
* 当线程想要获取写入锁定时：
* -->已经有线程在执行写入，则等待。不等待，则发生write-write conflick
* -->已经有线程在执行读取，则等待。不等待，则发生read-write conflick

--->利用同时（读取）不会引起数据冲突的特性，提高系统的性能
--->适合读取操作繁重时
--->适合读取操作比写入操作繁重时

三：Read-Write Lock Pattern思考
--->
四进阶说明
--->

读写锁

 1 package com.yeepay.sxf.thread6;
 2 /**
 3  * 读写锁
 4  * @author sxf
 5  * 
 6  * 为了多线线程环境下保护数据安全，我们必须避免的冲突
 7  * 一个线程读取，另一个线程写入的read-write conflick
 8  * 一个线程写入，另一个线程写入的write-write conflick
 9  * 一个线程读取，另一个线程也在读取不会产生冲突
10  * 
11  * 当线程想要获取读取锁定时：
12  *         -->已经有线程在执行写入，则等待。不等待，则发生read-write conflick
13  *         -->已经有线程在读取，则不需要等待。不存在read-read conflick
14  * 
15  * 当线程想要获取写入锁定时：
16  *         -->已经有线程在执行写入，则等待。不等待，则发生write-write conflick
17  *         -->已经有线程在执行读取，则等待。不等待，则发生read-write conflick
18  *
19  */
20 public class ReadWriteLock {
21         //正在读取的线程个数
22         private Integer readInteger=0;
23         //正在写入的线程个数（最大值为1）
24         private Integer writeInteger=0;
25         //正在等待获取写入锁定的线程个数
26         private Integer writeWaitInteger=0;
27         //获取写入锁定优先的话，为true
28         private boolean writeBoolean=false;
29         
30         //获取读取锁的方法
31         public synchronized void readLock() throws InterruptedException{
32             //如果有写入操作  ||写入优先并且存在等待写入的线程    则    读取线程等待
33             while(writeInteger>0||(writeBoolean&&writeWaitInteger>0)){
34                 wait();
35             }
36             //读取线程加1
37             readInteger++;
38         }
39         //释放读取锁定的方法
40         public synchronized void readUnLock(){
41             //读取减一
42             readInteger--;
43             //将写入设置优先
44             writeBoolean=true;
45             //唤醒所有线程
46             notifyAll();
47         }
48         
49         //获取写入锁定
50         public synchronized void writeLock() throws InterruptedException{
51             //等待写入线程数量+1
52             writeWaitInteger++;
53             try {
54                 //如果有读取线程或写入线程，则等待
55                 while (readInteger>0||writeInteger>0) {
56                     wait();
57                 }
58             }finally{
59                 //执行到这，等待线程-1
60                 writeWaitInteger--;
61             }
62             //写入线程数+1
63             writeInteger++;
64         }
65         
66         
67         //释放写入锁定
68         public synchronized void  writeUnLock(){
69             //写入线程数-1
70             writeInteger--;
71             //写入的优先级去掉
72             writeBoolean=false;
73             //唤醒其他线程
74             notifyAll();
75         }
76 
77 }

View Code