使用ReetrantReadWriteLock类加快运行效率
使用ReetrantReadWriteLock类加快运行效率
在JDK中提供了一种读写锁ReetrantReadWriteLock类，使用它可以加快运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReetrantReadWriteLock来提升该方法的代码运行速度。
读写锁也有2个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，而进行写入操作Thread只有在获取写锁后才能进入写入操作。即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。
一.类ReetrantReadWriteLock的使用：读读共享
package service;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
public class Service {
privateReentrantReadWriteLock lock = new ReentrantReadWriteLock();
publicvoid read() {
try{
try{
lock.readLock().lock();
System.out.println("获得读锁" + Thread.currentThread().getName()
+" " + System.currentTimeMillis());
Thread.sleep(10000);
}finally {
lock.readLock().unlock();
}
}catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
新建ThreadA.java ：
package extthread;
import service.Service;
public class ThreadA extends Thread {
privateService service;
publicThreadA(Service service) {
super();
this.service= service;
}
@Override
publicvoid run() {
service.read();
}
}
新建ThreadB.java ：
package extthread;
import service.Service;
public class ThreadB extends Thread {
privateService service;
publicThreadB(Service service) {
super();
this.service= service;
}
@Override
publicvoid run() {
service.read();
}
}
新建Run.java :
package test;
import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;
public class Run {
publicstatic void main(String[] args) {
Serviceservice = new Service();
ThreadAa = new ThreadA(service);
a.setName("A");
ThreadBb = new ThreadB(service);
b.setName("B");
a.start();
b.start();
}
}
运行结果：
从控制台打印时间来看，2个线程几乎同时进入了lock()方法后面的代码，说明在使用了lock.readLock()读锁可以提高程序运行效率，允许多个线程同时执行lock()方法后面的代码。
二.类ReetrantReadWriteLock的使用：写写互斥
新建Service.java :
package service;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
public class Service {
privateReentrantReadWriteLock lock = new ReentrantReadWriteLock();
publicvoid write() {
try{
try{
lock.writeLock().lock();
System.out.println("获得写锁" + Thread.currentThread().getName()
+" " + System.currentTimeMillis());
Thread.sleep(10000);
}finally {
lock.writeLock().unlock();
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
其他类和上面的一样。
程序运行结果：
使用写锁代码lock.writeLock()的效果就是同一时间只允许一个线程执行lock()后面的代码。
三.类ReetrantReadWriteLock的使用：读写互斥
修改Service.java:
package service;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
public class Service {
privateReentrantReadWriteLock lock = new ReentrantReadWriteLock();
publicvoid read() {
try{
try{
lock.readLock().lock();
System.out.println("获得读锁" + Thread.currentThread().getName()
+" " + System.currentTimeMillis());
Thread.sleep(10000);
}finally {
lock.readLock().unlock();
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
publicvoid write() {
try{
try{
lock.writeLock().lock();
System.out.println("获得写锁" + Thread.currentThread().getName()
+" " + System.currentTimeMillis());
Thread.sleep(10000);
}finally {
lock.writeLock().unlock();
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
新建Run.java :
package test;
import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;
public class Run {
publicstatic void main(String[] args) throws InterruptedException {
Serviceservice = new Service();
ThreadAa = new ThreadA(service);
a.setName("A");
a.start();
Thread.sleep(1000);
ThreadBb = new ThreadB(service);
b.setName("B");
b.start();
}
}
运行结果如下：
由此可见，读写操作时互斥的，只要出现写操作过程，就是互斥的。