五、读写锁-ReentrantReadWriteLock

这里介绍读写锁的演变

1、使用synchronized来控制读写

使用synchronized 对修改、删除、添加操作加锁，对查询操作不加锁时就会产生脏读。如下代码，对写加synchronized 读不加

package deadlock;

/**
 * 演示脏读
 * 对修改、删除、添加操作加锁，
 * 对查询操作不加锁时就会产生脏读
 * 写的过程中 不能查看 要互斥
 * @author xzq
 */
public class DirtyRead {

    static class Person{

        private String name;
        private boolean hitedSuccess=false;

        public  synchronized void hited(String name,boolean hitedSuccess) throws InterruptedException{
            this.name=name;
            Thread.sleep(2_000);
            this.hitedSuccess=hitedSuccess;
        }
        public /*synchronized*/ boolean see(String name){
            return this.hitedSuccess;
        }
    }


    public static void main(String[] args) throws InterruptedException {

        final Person p=new Person();
        new Thread("无相皇"){
            @Override
            public void run() {
                try {
                    p.hited("幽灵密探",true);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();

        Thread.sleep(1_000);

        System.out.println("幽灵密探被打中了么："+p.see("幽灵密探"));

        Thread.sleep(1_000);

        System.out.println("幽灵密探被打中了么："+p.see("幽灵密探"));
    }

}

出现脏读，结果如下
读和写都加synchronized可以避免脏读，结果如下：
虽然解决了脏读问题，但效率很低，在读的时候其他线程不可以进入查看。所以引入ReentrantReadWriteLock 读写锁 效率就会高很多。
ReadWriteLock readWriteLock=new ReentrantReadWriteLock();

readWriteLock.readLock().lock();
…处理业务…
finally{readWriteLock.readLock().unlock();}
readWriteLock.readLock().unlock(); 必须要写在finally中

代码如下

package day03.part1;

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

/**
 * 解决脏读问题
 * 这里使用读写锁去实现同步，
 * 就比直接用synchronized高效很多
 * @author xzq
 */
public class SolveDirtyRead {

    static class Person{

        private String name;

        private boolean hitedSuccess=false;

        private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();

        public  void hited(String name,boolean hitedSuccess){
            readWriteLock.writeLock().lock();
            try {
                this.name=name;
                Thread.sleep(2_000);
                this.hitedSuccess=hitedSuccess;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                readWriteLock.writeLock().unlock();
            }
        }

        public boolean see(String name){
            readWriteLock.readLock().lock();
            try {
                return this.hitedSuccess;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                readWriteLock.readLock().unlock();
            }
            System.out.println("走的默认没打中的地方……");
            return false;
        }

    }


    public static void main(String[] args) throws InterruptedException {

        final Person p=new Person();
        new Thread("无相皇"){
            @Override
            public void run() {
                p.hited("幽灵密探",true);
            }
        }.start();

        Thread.sleep(1_000);

        System.out.println("幽灵密探被打中了么："+p.see("幽灵密探"));

        Thread.sleep(1_000);

        System.out.println("幽灵密探被打中了么："+p.see("幽灵密探"));
    }

}

结果如下

下面是读写锁的另一个例子

• 读写锁的用法
• 将锁的类别更加细化的一种解决问题的方式，
• 能更好的提高效率
• see和change方法上加synchronized 可以解决脏读的问题，但效率低 see的时候其他线程无法进入查看see
• 1、读写锁内部维护了两个锁，一个读锁，一个写锁
• 2、读锁与读锁不互斥（可以并行读）
• 3、读锁与写锁互斥（不能并行读和写）
• 4、写锁与写锁互斥（不能并行写）

package day03.part1;

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

/**
 * 读写锁的用法
 * 将锁的类别更加细化的一种解决问题的方式，
 * 能更好的提高效率
 * see和change方法上加synchronized 可以解决脏读的问题，但效率低 see的时候其他线程无法进入查看see
 * 1、读写锁内部维护了两个锁，一个读锁，一个写锁
 * 2、读锁与读锁不互斥（可以并行读）
 * 3、读锁与写锁互斥（不能并行读和写）
 * 4、写锁与写锁互斥（不能并行写）
 * @author xzq
 */
public class ReadWriteLockTest01 {

    public static void main(String[] args) {
        final BigHouse bigHouse = new BigHouse();
        //创建3个人去看黄金
        for(int i=0;i<3;i++){
            new Thread("看的人"+(i+1)){
                public void run(){
                    while(true){
                        bigHouse.see();
                    }
                }
            }.start();
        }
        //创建2个人去拿黄金
        for (int i = 0; i < 2; i++) {
            new Thread("拿的人"+(i+1)){
                public void run(){
                    while(true){
                        bigHouse.change(1);
                    }
                }
            }.start();
        }
    }

}


class  BigHouse{

    /*
     * 共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
     */
    private int count =10;

    public String name="黄金";

    /**
     * 这个房子上有一个读写锁
     */
    private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();

    /*
     see和change方法上加synchronized 可以解决脏读的问题，但效率低 see的时候其他线程无法进入查看see
     */
    public /*synchronized*/ void  see() {
       readWriteLock.readLock().lock();
        try {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName+ "：正走进一点准备看这个"+name);
            //走到能看清黄金的地方用了2秒
            Thread.sleep(2_000);
            System.out.println(threadName + "：已经看清了是：" +name+"有"+ count+"块");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }   finally{
           readWriteLock.readLock().unlock();
        }
    }

    public /*synchronized*/ void change(int num){
       readWriteLock.writeLock().lock();
        try {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName+ "：正走进一点准备拿走这个"+name);
            //走到能拿走这个黄金的地方用了3秒
            Thread.sleep(1_000);
            this.count=count-num;
            System.out.println(threadName + "：拿走1块黄金后还有：" + count+"块");
        } catch (InterruptedException e) {

        }finally{
           readWriteLock.writeLock().unlock();
        }
    }


}