多线程程序设计学习（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思考
--->
四进阶说明
--->

读写锁

 package com.yeepay.sxf.thread6;
 /**
  * 读写锁
  * @author sxf
  *
  * 为了多线线程环境下保护数据安全，我们必须避免的冲突
  * 一个线程读取，另一个线程写入的read-write conflick
  * 一个线程写入，另一个线程写入的write-write conflick
  * 一个线程读取，另一个线程也在读取不会产生冲突
  *
  * 当线程想要获取读取锁定时：
  *         -->已经有线程在执行写入，则等待。不等待，则发生read-write conflick
  *         -->已经有线程在读取，则不需要等待。不存在read-read conflick
  *
  * 当线程想要获取写入锁定时：
  *         -->已经有线程在执行写入，则等待。不等待，则发生write-write conflick
  *         -->已经有线程在执行读取，则等待。不等待，则发生read-write conflick
  *
  */
 public class ReadWriteLock {
         //正在读取的线程个数
         private Integer readInteger=0;
         //正在写入的线程个数（最大值为1）
         private Integer writeInteger=0;
         //正在等待获取写入锁定的线程个数
         private Integer writeWaitInteger=0;
         //获取写入锁定优先的话，为true
         private boolean writeBoolean=false;

         //获取读取锁的方法
         public synchronized void readLock() throws InterruptedException{
             //如果有写入操作  ||写入优先并且存在等待写入的线程    则    读取线程等待
             while(writeInteger>0||(writeBoolean&&writeWaitInteger>0)){
                 wait();
             }
             //读取线程加1
             readInteger++;
         }
         //释放读取锁定的方法
         public synchronized void readUnLock(){
             //读取减一
             readInteger--;
             //将写入设置优先
             writeBoolean=true;
             //唤醒所有线程
             notifyAll();
         }

         //获取写入锁定
         public synchronized void writeLock() throws InterruptedException{
             //等待写入线程数量+1
             writeWaitInteger++;
             try {
                 //如果有读取线程或写入线程，则等待
                 while (readInteger>0||writeInteger>0) {
                     wait();
                 }
             }finally{
                 //执行到这，等待线程-1
                 writeWaitInteger--;
             }
             //写入线程数+1
             writeInteger++;
         }

         //释放写入锁定
         public synchronized void  writeUnLock(){
             //写入线程数-1
             writeInteger--;
             //写入的优先级去掉
             writeBoolean=false;
             //唤醒其他线程
             notifyAll();
         }

 }

数据类（公共资源）

 package com.yeepay.sxf.thread6;
 /**
  * 数据类
  * 持有公共数据+该公共数据的读写锁
  * @author sxf
  *
  */
 public class Data {
     //数据类持有的锁
     private final ReadWriteLock lock=new ReadWriteLock();
     //要访问的公共数据
     private final String[] buffer;
     //构造器
     public Data(int i){
         buffer=new String[i];
         for(int a=0;a<buffer.length;a++){
             buffer[a]="**";
         }
     }
     //读取数据的方法
     public  String[] read() throws InterruptedException{
         //获取读取锁定
         lock.readLock();
         try {
             //模拟读用了1秒
             Thread.sleep(1000);
             return doRead();
         } finally{
             //释放读取锁定
             lock.readUnLock();
         }

     }
     //真正的读取操作
     private String[] doRead(){
         return buffer;
     }

     //写入的操作
     public void write(String a) throws InterruptedException{
         //获取写入锁定
         lock.writeLock();
         try {
             //模拟写用了3秒
             Thread.sleep(1000);
             doWrite(a);
         }finally{
             //释放写入锁定
             lock.writeUnLock();
         }

     }

     //真正的写操作
     private void doWrite(String a){
         for(int i=0;i<buffer.length;i++){
             buffer[i]=a;
         }
     }

 }

读线程

 package com.yeepay.sxf.thread6;

 /**
  * 读线程
  * @author sxf
  *
  */
 public class ReadThread implements Runnable{

     private Data data;

     //构造器
     public ReadThread(Data data) {

         this.data=data;
     }
     @Override
     public void run() {
         while (true) {
                 try {
                     String [] aStrings=data.read();
                     System.out.println("["+Thread.currentThread().getName()+"] 读取数据为："+aStrings[0]);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
         }

     }

 }

写线程

 package com.yeepay.sxf.thread6;
 /**
  * 写线程
  *  * @author sxf
  *
  */
 public class WriteThead implements Runnable {
     //数据
     private Data data;

     //构造器
     public  WriteThead(Data data) {
         this.data=data;
     }

     @Override
     public void run() {

         while(true){
             for(int a=0;a<100;a++){
                 String name=Thread.currentThread().getName();
                 System.out.println("【"+name+"】写入"+a+"*"+name.substring(name.length()-2));
                 try {
                     data.write(a+"*"+name.substring(name.length()-2));
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }
     }

 }

测试类

 package com.yeepay.sxf.thread6;
 /**
  * 测试类
  * @author sxf
  *
  */
 public class Test {

     public static void main(String[] args) {
         //声明公共数据类
         Data data=new Data(2);
         //声明读取线程
         Thread readThread1=new Thread(new ReadThread(data));
         readThread1.setName("读取线程sxf");
         Thread readThread2=new Thread(new ReadThread(data));
         readThread2.setName("读取线程sxs");
         Thread readThread3=new Thread(new ReadThread(data));
         readThread3.setName("读取线程sxy");

         //声明写入线程
         Thread writeThread1=new Thread(new WriteThead(data));
         writeThread1.setName("写入线程yk");
         Thread writeThread2=new Thread(new WriteThead(data));
         writeThread2.setName("写入线程shl");
         Thread writeThread3=new Thread(new WriteThead(data));
         writeThread3.setName("写入线程shj");

         //开启线程
         readThread1.start();
         readThread2.start();
         readThread3.start();

         writeThread1.start();
         writeThread2.start();
         writeThread3.start();

     }
 }

打印结果

【写入线程yk】写入0*yk
【写入线程shj】写入0*hj
【写入线程shl】写入0*hl
[读取线程sxf] 读取数据为：**
[读取线程sxy] 读取数据为：**
[读取线程sxs] 读取数据为：**
【写入线程shj】写入1*hj
[读取线程sxs] 读取数据为：0*hj
[读取线程sxy] 读取数据为：0*hj
[读取线程sxf] 读取数据为：0*hj
【写入线程shj】写入2*hj
[读取线程sxf] 读取数据为：1*hj
[读取线程sxy] 读取数据为：1*hj
[读取线程sxs] 读取数据为：1*hj
【写入线程shl】写入1*hl
【写入线程shj】写入3*hj
【写入线程shl】写入2*hl
【写入线程shj】写入4*hj
【写入线程shl】写入3*hl
【写入线程shj】写入5*hj
【写入线程shl】写入4*hl