Java~使用ReentrantReadWriteLock类实现: 读读共享, 写写互斥, 读写互斥,写读互斥

ReentrantReadWriteLock类

• 类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务。这样做虽然保证了实例变量的线程安全性，但效率却是非常低下的。所以在JDK中提供了一种读写锁ReentrantReadWriteLock类，使用它可以加快运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriteLock来提升该方法的代码运行速度。读写锁表示也有两个锁，一个是读操作相关的锁，也称为共享锁;另一个是写操作相关的锁，也叫排他锁。 也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进行写入操作。即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写人操作。

读读共享

• 服务类

public class Service {

    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void read() {
        readWriteLock.readLock().lock();
        System.out.println(Thread.currentThread().getName() + " 开始读数据 " +
                new Date().toString());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " 读数据完毕 " +
                    new Date().toString());
            readWriteLock.readLock().unlock();
        }
    }

    public void write() {
        readWriteLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + " 开始写数据 " +
                new Date().toString());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " 写数据完毕 " +
                    new Date().toString());
            readWriteLock.writeLock().unlock();
        }
    }

}

• 运行类

public class Demo1 {

    public static void main(String[] args) {
        //演示读读共享
        Service service = new Service();
        Thread a = new Thread("A") {
            @Override
            public void run() {
                service.read();
            }
        };
        Thread b = new Thread("B") {
            @Override
            public void run() {
                service.read();
            }
        };
        a.start();
        b.start();
    }

}

• 从控制台中打印的时间来看，两个线程几乎同时进入lock()方法后面的代码。说明在此使用了lock.readLock()读锁可以提高程序运行效率，允许多个线程同时执行lock()方法后面的代码。

写写互斥

• 运行类

public class Demo2 {

    public static void main(String[] args) {
        //演示写写互斥
        Service service = new Service();
        Thread a = new Thread("A") {
            @Override
            public void run() {
                service.write();
            }
        };
        Thread b = new Thread("B") {
            @Override
            public void run() {
                service.write();
            }
        };
        a.start();
        b.start();
    }
}

• 使用写锁代码lock.wielock()的效果就是同-一时间只允许一个线程执行lock()方法后面的代码。

读写互斥

• 运行类

public class Demo3 {

    public static void main(String[] args) {
        //演示读写互斥
        Service service = new Service();
        Thread a = new Thread("A") {
            @Override
            public void run() {
                service.read();
            }
        };
        Thread b = new Thread("B") {
            @Override
            public void run() {
                service.write();
            }
        };
        a.start();
        b.start();
    }
}

写读互斥

• 运行类

public class Demo4 {

    public static void main(String[] args) {
        //演示写写互斥
        Service service = new Service();
        Thread a = new Thread("A") {
            @Override
            public void run() {
                service.write();
            }
        };
        Thread b = new Thread("B") {
            @Override
            public void run() {
                service.read();
            }
        };
        a.start();
        b.start();
    }
}

• “读写”、“写读”和“写写”都是互斥的;而“读读”是异步的，非互斥的。 “读写”、“写读”和“写写”都是互斥的;而“读读”是异步的，非互斥的。
• 即只要出现“写操作”的过程，就是互斥的。

实现原理

• 首先写锁是一个排它锁, 也就是如果一个线程获得了读锁, 就会修改标志位, 其他线程想要获取无论是读锁, 还是写锁, 都会发现这个标记位, 那么这些线程就会知道这段同步代码段正在执行写操作, 就会进入等待队列等写锁的释放, 还需要知道写锁是一个可重入的锁, 当写锁释放的时候和synchronized一样会有一个计数器, 如果计时器为0了, 就表示正常释放了写锁
• 读锁是一个共享锁, 说他是共享锁其实他只给其他要读的线程共享,如果一个线程是写线程, 他是不会共享的, 当然这也是一个可重入的锁, 并且也有一个计数器去判断锁的释放
• 在读写锁还会有一个锁降级的事情, 这里说的锁降级和偏向锁到轻量级锁到重量级锁的降级不是一回事, 这里的所降级是指如果当前线程已经获取了写锁, 然后又要获取读锁的时候, 线程会先判断这个线程有没有是不是用有写锁, 如果拥有就会释放掉这个写锁马上获取到读锁. 这个过程称为读写锁的降级过程.