public interface Lock {
void lock();
void unlock();
}
public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}
public class SimpleReadWriteLock implements ReadWriteLock {
private int readers;
private boolean writer;
private Lock readLock;
private Lock writeLock;
private final Object lockObj;
public SimpleReadWriteLock() {
readers = 0;
writer = false;
lockObj = new Object();
readLock = new ReadLock();
writeLock = new WriteLock();
}
@Override
public Lock readLock() {
return readLock;
}
@Override
public Lock writeLock() {
return writeLock;
}
private class ReadLock implements Lock {
@Override
public void lock() {
try {
synchronized (lockObj) {
while (writer) {
lockObj.wait();//有线程持有写锁,其他线程不能获得读锁
}
++readers;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void unlock() {
synchronized (lockObj) {
--readers;
if (readers == 0) {
lockObj.notifyAll();//没有线程持有读锁,唤醒等待的写线程
}
}
}
}
private class WriteLock implements Lock {
@Override
public void lock() {
try {
synchronized (lockObj) {
while (readers > 0 || writer) {
lockObj.wait();//有线程持有读锁或者写锁,其他线程不能获得写锁
}
writer = true;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void unlock() {
synchronized (lockObj) {
writer = false;
lockObj.notifyAll();//释放写锁,唤醒等待中的读线程或者写线程
}
}
}
}
public class SimpleReadWriteLock implements ReadWriteLock {
private int readers;
private boolean writer;
private Lock readLock;
private Lock writeLock;
private final Object lockObj;
public SimpleReadWriteLock() {
readers = 0;
writer = false;
lockObj = new Object();
readLock = new ReadLock();
writeLock = new WriteLock();
}
@Override
public Lock readLock() {
return readLock;
}
@Override
public Lock writeLock() {
return writeLock;
}
private synchronized void read_lock() {
try {
while (writer) {
wait();//有线程持有写锁,其他线程不能获得读锁
}
++readers;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private synchronized void read_unlock() {
--readers;
if (readers == 0) {
notifyAll();//没有线程持有读锁,唤醒等待的写线程
}
}
private synchronized void write_lock() {
try {
while (readers > 0 || writer) {
wait();//有线程持有读锁或者写锁,其他线程不能获得写锁
}
writer = true;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private synchronized void write_unlock(){
writer = false;
notifyAll();//释放写锁,唤醒等待中的读线程或者写线程
}
private class ReadLock implements Lock {
@Override
public void lock() {
read_lock();
}
@Override
public void unlock() {
read_unlock();
}
}
private class WriteLock implements Lock {
@Override
public void lock() {
write_lock();
}
@Override
public void unlock() {
write_unlock();
}
}
}
测试示例:
public class TestSRWLock {
private int value = 0;
private Lock readLock;
private Lock writeLock;
public TestSRWLock() {
SimpleReadWriteLock srwLock = new SimpleReadWriteLock();
readLock = srwLock.readLock();
writeLock = srwLock.writeLock();
}
public void test() {
Thread read1 = new ReadThread();
Thread read2 = new ReadThread();
Thread write1 = new WriteThread();
Thread write2 = new WriteThread();
write1.start();
read1.start();
write2.start();
read2.start();
}
public void read() {
readLock.lock();
try {
System.out.println("Thread: " + Thread.currentThread().getName() + " getReadLock");
System.out.println("value = " + value);
} finally {
readLock.unlock();
}
}
public void write() {
writeLock.lock();
try {
System.out.println("Thread: " + Thread.currentThread().getName() + " getWriteLock");
++value;
System.out.println("value = " + value);
} finally {
writeLock.unlock();
}
}
private class ReadThread extends Thread {
@Override
public void run() {
read();
}
}
private class WriteThread extends Thread {
@Override
public void run() {
write();
}
}
}
测试结果:
Thread: Thread-2 getWriteLock
value = 1
Thread: Thread-0 getReadLock
value = 1
Thread: Thread-3 getWriteLock
value = 2
Thread: Thread-1 getReadLock
value = 2
Thread: Thread-2 getWriteLock
value = 1
Thread: Thread-0 getReadLock
value = 1
Thread: Thread-1 getReadLock
value = 1
Thread: Thread-3 getWriteLock
value = 2