多线程之读写锁（十八）

1. synchronized内部锁与ReentrantLock锁都是独占锁(排它锁)，同一时间只允许一个线程执行同步代码块，可以保证线程的安全性，但是执行效率低。
2. ReentrantReadWriteLock读写锁是一种改进的排它锁，也可以称作共享/排它锁，语序多个线程同时读取共享数据，但是一次只允许一个线程对共享数据进行更新
3. 读写锁通过读锁和写锁；来完成操作，线程在读取共享数据前，必须先持有读锁，该读锁可以同时被多个线程持有，即他是共享的，写锁是排他的，
4. 线程在更新共享数据前必须先持有写锁,一个线程持有写锁是其他线程无法获得相应的锁
5. 读锁只是在读线程之间共享，任何一个线程持有读锁时其他线程都无法获得写锁,保证了线程在读取期间没有其他线程对数据进行更新，使得读线程能够读到数据的最新值，保证在读数据期间共享变量不被修改

读写锁允许读读共享、读写互斥，写写互斥

一、读写锁的基本使用

在java.util.concurrent.locks包中定义了ReadWriteLock接口，该接口中定义了readLock（）返回读锁，定义writeLock方法返回写锁，该接口的实现类ReentrantReadWriteLock。

注意：readLock（）和writeLock方法返回的锁对象是同一个锁的两个不同角色，不是分别获取的两个不同的锁.ReadWriteLock接口的实例可以充当两个角色,

//读写锁基本使用方法

//定义读写锁
 ReadWriteLock   rwLock = new ReentrantReadWriteLock();

//获取读锁
Lock readLock = rwLock.readLock();

//获得写锁
Lock writeLock = rwLock.writeLock();

//读数据
try{
readLock.lock();//申请读锁
//读取共享数据

}finally{
	//读锁释放
readLock.unlock();

}

//写数据
try{
writeLock.lock(); //申请写锁
//修改共享数据
}finally{
	//写锁释放
writeLock.unlock();
}

1. 读读共享

ReadWriteLock 读写锁可以实现多个线程同时读取数据，即读读共享，可以调高程序的读取数据的效率

package com.dome.lock.readWrite;

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

/**
 * @author qb
 * @version 1.0
 * @Description
 * ReadWriteLock 读写锁 ，实现读读共享，允许多个线程同时获取读锁
 * @date 2021/3/11 15:54
 */
public class Test01 {


    static class Service{
        //定义读写锁
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        //定义方法读取数据
        public void read(){
            try {
                readWriteLock.readLock().lock();  //获得读锁
                System.out.println(Thread.currentThread().getName() +"获得读锁，开始读取数据的时间--"+System.currentTimeMillis());
                TimeUnit.SECONDS.sleep(3); //模拟读取数据用时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放读锁
                readWriteLock.readLock().unlock();
            }
        }

        public static void main(String[] args) {


            Service service = new Service();

            //创建5个线程，调用read()方法
            for (int i = 0; i < 5; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        service.read();  //读取数据
                    }
                }).start();
            }

            //运行程序后多个线程几乎可以同时获得读锁执行lock后面的代码



        }

    }



}

2. 写写互斥

通过ReadWriteLock中的写锁，只允许有一个线程执行lock后面的代码

package com.dome.lock.readWrite;

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

/**
 * @author qb
 * @version 1.0
 * @Description
 *
 * 通过ReadWriteLock中的写锁，只允许有一个线程执行lock后面的代码
 *
 *
 * @date 2021/3/11 16:04
 */
public class Test02 {

    static class Service{
        //读写锁
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        //定义方法修改数据
        public void write(){
            try {
                readWriteLock.writeLock().lock();  //申请获得写锁
                System.out.println(Thread.currentThread().getName()+"获得写锁，开始修改数据的时间--"+System.currentTimeMillis());
                Thread.sleep(3000); //模拟修改数据的用时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() +"修改数据完毕的时间--"+System.currentTimeMillis());
                readWriteLock.writeLock().unlock();

            }
        }


    }

    public static void main(String[] args) {


        Service service = new Service();

        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    service.write();
                }
            }).start();
        }

        //从结果上看，同一时间只有一个线程获得写锁
    }
}

3 读写互斥

写锁是独占锁，是排它锁，读线程和写线程是互斥的

package com.dome.lock.readWrite;

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

/**
 * @author qb
 * @version 1.0
 * @Description
 *
 * 一个线程获得读锁时其他线程等待，一个线程获取写锁时，其他线程等待
 *
 * @date 2021/3/11 16:04
 */
public class Test03 {

    static class Service{
        //读写锁
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
//        Lock readLock = readWriteLock.readLock();  //读锁

        //定义方法修改数据
        public void write(){
            try {
                readWriteLock.writeLock().lock();  //申请获得写锁
                System.out.println(Thread.currentThread().getName()+"获得写锁，开始修改数据的时间--"+System.currentTimeMillis());
                Thread.sleep(3000); //模拟修改数据的用时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() +"修改数据完毕的时间--"+System.currentTimeMillis());
                readWriteLock.writeLock().unlock();

            }
        }

        //定义方法读取数据
        public void read(){
            try {
                readWriteLock.readLock().lock();  //申请获得读锁
                System.out.println(Thread.currentThread().getName()+"获得读锁，开始读取数据的时间--"+System.currentTimeMillis());
                Thread.sleep(3000); //模拟读取数据的用时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() +"读取数据完毕的时间--"+System.currentTimeMillis());
                readWriteLock.readLock().unlock();

            }
        }


    }

    public static void main(String[] args) {


        Service service = new Service();

        //定义一个线程读数据
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.read();
            }
        }).start();

        //定义线程写数据
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.write();
            }
        }).start();

    }
}