Java多线程读写锁

synchronized内部锁与ReentrantLock锁都是独占锁(排它锁), 同一时间只允许一个线程执行同步代码块,可以保证线程的安全性,但是执行效率低。

ReentrantReadWriteLock读写锁是一种改进的排他锁,也可以称作共享/排他锁. 允许多个线程同时读取共享数据,但是一次只允许一个线程对共享数据进行更新。

读写锁通过读锁与写锁来完成读写操作. 线程在读取共享数据前必须先持有读锁,该读锁可以同时被多个线程持有,即它是共享的.线程在修改共享数据前必须先持有写锁,写锁是排他的, 一个线程持有写锁时其他线程无法获得相应的锁。

读锁只是在读线程之间共享,任何一个线程持有读锁时,其他线程都无法获得写锁, 保证线程在读取数据期间没有其他线程对数据进行更新,使得读线程能够读到数据的最新值,保证在读数据期间共享变量不被修改。

读写锁允许读读共享, 读写互斥,写写互斥。

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

注意readLock()与writeLock()方法返回的锁对象是同一个锁的两个不同的角色, 不是分别获得两个不同的锁. ReadWriteLock接口实例可以充当两个角色.读写锁的其他使用方法。

//定义读写锁
ReadWriteLock  rwLock = new ReentrantReadWriteLock();
//获得读锁
Lock readLock = rwLock.readLock();
//获得写锁
Lock writeLock = rwLock.writeLock();
//读数据
readLock.lock();		//申请读锁
try{
   读取共享数据
}finally{
   readLock.unlock();  //总是在finally子句中释放锁
}
//写数据
writeLock.lock(); 		//申请写锁
try{
   更新修改共享数据
}finally{
   writeLock.unlock();  //总是在finally子句中释放锁
}

读读共享

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

package com.wkcto.lock.readwrite;

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

/**
 * ReadWriteLock读写锁可以实现读读共享,允许多个线程同时获得读锁
 */
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();     //在线程中调用read()读取数据
                }
            }).start();
        }
        //运行程序后,这多个 线程几乎可以同时获得锁读,执行lock()后面的代码
    }
}

写写互斥

通过ReadWriteLock读写锁中的写锁,只允许有一个线程执行lock()后面的代码。

package com.wkcto.lock.readwrite;

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

/**
 * 演示ReadWriteLock的writeLock()写锁是互斥的,只允许有一个线程持有
 */
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();

        //创建5个线程修改数据
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    service.write();    //调用修改数据的方法
                }
            }).start();
        }
        //从执行结果来看,同一时间只有一个线程获得写锁
    }
}

读写互斥

写锁是独占锁,是排他锁,读线程与写线程也是互斥的。

package com.wkcto.lock.readwrite;

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

/**
 * 演示ReadWriteLock的读写互斥
 *  一个线程获得读锁时,写线程等待; 一个线程获得写锁时,其他线程等待
 */
public class Test03 {
    static class Service{
        //先定义读写锁
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        Lock readLock = readWriteLock.readLock();       //获得读锁
        Lock writeLock = readWriteLock.writeLock();     //获得写锁
        //定义方法读取数据
        public void read(){
            try {
                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());
                readLock.unlock();     //释放读锁
            }
        }
        //定义方法修改数据
        public void write(){
            try {
                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());
                writeLock.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();
    }
}