ReadWriteLock
ReadWriteLock是一个接口
public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing
*/
Lock writeLock();
}
一个用来获取读锁,一个用来获取写锁。将文件的读写操作分开,分成2个锁来分配线程,从而实现多个线程可以同时进行读操作。
实现类–ReentrantReadWriteLock
对于一般的锁,入ReentrantLock,其一般都是“独占式”,也即在同一时刻只能有一个线程能够访问锁定的代码。如果对于共享资源的访问“读”多于“写”,那么“独占锁”没有读写锁的效率高。所谓“读写锁”指的是对共享资源的访问提供一个读锁和一个写锁,当访问方式是读取操作时使用度锁即可,当访问方式是修改操作时,则使用写锁。读锁和写锁之间有一定的制约性。
- 当有读锁锁定资源时,其余的读锁可以共享式的访问资源,但是会阻塞写锁对资源的获取。
- 当有写锁锁定资源时,将阻塞其余所有的读锁(除了该线程本身–重入)和写锁的获取。
示例
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Demo11 {
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
int m = 100;
public static void main(String[] args) {
Demo11 d = new Demo11();
new Thread(new Runnable() {
@Override
public void run() {
d.get(Thread.currentThread());
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
d.get2(Thread.currentThread());
}
}).start();
}
public void get(Thread thread){
// rwLock.readLock().lock();
//如果为写锁,则当前线程执行此方法,另一个线程想执行另一个get2()方法获取读锁,无法获取
rwLock.writeLock().lock();
try {
int a = 10;
while (a>=0) {
a--;
m--;
System.out.println(thread.getName() + "正在写"+",m="+m);
TimeUnit.SECONDS.sleep(1);
}
System.out.println("写操作完毕");
}catch (Exception e){
}finally {
// rwLock.readLock().unlock();
rwLock.writeLock().unlock();
}
}
public void get2(Thread thread){
rwLock.readLock().lock();
try {
int a = 10;
while (a>=0) {
m--;
a--;
System.out.println(thread.getName() + "正在读"+",m="+m);
TimeUnit.SECONDS.sleep(1);
}
System.out.println("读操作完毕");
}catch (Exception e){
}finally {
rwLock.readLock().unlock();
}
}
}
ReentrantReadWriteLock具有重入性。
package cn.tedu.concurrent;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* synchronized的造成的阻塞可重入
*/
public class ReentrantDemo1 {
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void m1(){
try {
readWriteLock.readLock().lock();
System.out.println("m1..start");
this.m2();
}finally {
readWriteLock.readLock().unlock();
}
}
public void m2(){
try {
readWriteLock.readLock().lock();
System.out.println("m2..start");
}finally {
readWriteLock.readLock().unlock();
}
}
public static void main(String[] args) {
ReentrantDemo1 rd = new ReentrantDemo1();
rd.m1();
}
}
Lock和synhronized的选择
首先先说明一点synchronized是支持重入锁的
package cn.tedu.concurrent;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* synchronized的造成的阻塞可重入
*/
public class ReentrantDemo1 {
public synchronized void m1(){
System.out.println("m1..start");
this.m2();
}
public synchronized void m2(){
System.out.println("m2..start");
}
public static void main(String[] args) {
ReentrantDemo1 rd = new ReentrantDemo1();
rd.m1();
}
}
Lock和synchronized有以下几点不同:
- Lock是一个接口,而synchronized是java中的关键字,synchronize的内置语言实现的
- synchronized在发生异常时,会自动释放线程线程占用的锁,因此不会导致死锁现象的发生;而Lock在发生异常的时候,如果没有主动通过unlock()方法去释放锁,则很可能造成死锁现象,因此使用Lock时需要在finally块中释放锁。
- Lock可以让等待锁的线程响应中断,而synchronized不行,使用synchronized时,等待的线程会一直等待下去,不能够响应中断。
- 通过Lock可以知道有没有成功获取锁,而synchronized无法办到
- Lock可以提高多个线程进行读操作的效率
jdk之后对synchronized进行了优化,所以在溢写并发量比较低的情况下二者的效率是差不多的。