将读取和写入分开来处理。读取数据前要获得读取的锁定，写入数据前要获得写入的锁定。多个线程可同时读取，而只有一个线程可以执行写入。将写入的共享互斥和读取的共享互斥分开思考，可以提高程序的性能。
操作系统中第一类Reader/Writer问题，读者有较高优先级；第二类中写者有较高优先级。本文采用可变优先级，通过一个boolean类型的成员变量preferWriter控制，当变量值为true时写者优先，当有写者等待时后续读者也会放弃控制权，进入等待状态；preferWriter为false时读者优先，无写者执行时会执行读取。这种方法巧妙避免了写者或读者的“饿死”。在readUnlock中将变量设为true，在writeUnlock中将变量设为false。
读写锁
final class ReadWriteLock {
private int readingReaders = 0;
private int waitingWriters = 0;
private int writingWriters = 0;
private boolean preferWriter = true;
public synchronized void readLock() throws InterruptedException {
while (writingWriters > 0 || (preferWriter && waitingWriters > 0)) {
wait();
}
readingReaders++;
}
public synchronized void readUnlock() {
readingReaders--;
preferWriter = true;
notifyAll();
}
public synchronized void writeLock() throws InterruptedException {
waitingWriters++;
try {
while (readingReaders > 0 || writingWriters > 0) {
wait();
}
} finally {
waitingWriters--;
}
writingWriters++;
}
public synchronized void writeUnlock() {
writingWriters--;
preferWriter = false;
notifyAll();
}
}
共享资源区
class SharedResource {
private final char[] buffer;
private final ReadWriteLock lock = new ReadWriteLock();
public SharedResource(int size) {
this.buffer = new char[size];
for (int i = 0; i < buffer.length; i++) {
buffer[i] = '*';
}
}
public char[] read() throws InterruptedException {
lock.readLock();
try {
return doRead();
} finally {
lock.readUnlock();
}
}
public void write(char c) throws InterruptedException {
lock.writeLock();
try {
doWrite(c);
} finally {
lock.writeUnlock();
}
}
private char[] doRead() {
char[] newbuf = new char[buffer.length];
for (int i = 0; i < buffer.length; i++) {
newbuf[i] = buffer[i];
}
slowly();
return newbuf;
}
private void doWrite(char c) {
for (int i = 0; i < buffer.length; i++) {
buffer[i] = c;
slowly();
}
}
private void slowly() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
}
}
}
读者线程
class ReaderThread extends Thread {
private final SharedResource data;
public ReaderThread(SharedResource data) {
this.data = data;
}
@Override
public void run() {
try {
while (true) {
char[] readbuf = data.read();
System.out.println(Thread.currentThread().getName() + " reads "
+ String.valueOf(readbuf));
}
} catch (InterruptedException e) {
}
}
}
写者线程
class WriterThread extends Thread {
private static final Random random = new Random();
private final SharedResource data;
private final String filler;
private int index = 0;
public WriterThread(SharedResource data, String filler) {
this.data = data;
this.filler = filler;
}
@Override
public void run() {
try {
while (true) {
char c = nextchar();
data.write(c);
System.out.println(Thread.currentThread().getName() + " writes "
+ String.valueOf(c));
Thread.sleep(random.nextInt(3000));
}
} catch (InterruptedException e) {
}
}
private char nextchar() {
char c = filler.charAt(index);
index++;
if (index >= filler.length()) {
index = 0;
}
return c;
}
}
测试类
public class Main {
public static void main(String[] args) {
SharedResource data = new SharedResource(8);
new ReaderThread(data).start();
new ReaderThread(data).start();
new ReaderThread(data).start();
new ReaderThread(data).start();
new WriterThread(data, "ABCDEFG").start();
new WriterThread(data, "abcdefg").start();
}
}
从
此处下载本文源文件。
posted on 2009-06-05 10:13
chenkkkabc 阅读(178)
评论(0) 编辑 收藏 所属分类:
设计模式