BlogJava-SexTian-文章分类-设计模式

Read-Write Lock模式

chenkkkabc — Fri, 05 Jun 2009 02:13:00 GMT

将读取和写入分开来处理。读取数据前要获得读取的锁定，写入数据前要获得写入的锁定。多个线程可同时读取，而只有一个线程可以执行写入。将写入的共享互斥和读取的共享互斥分开思考，可以提高程序的性能。
操作系统中第一类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();
    }
}

从此处下载本文源文件。

chenkkkabc 2009-06-05 10:13 发表评论

Producer-Consumer模式

chenkkkabc — Thu, 04 Jun 2009 04:35:00 GMT

生产者指产生数据的线程，消费者指使用数据的线程。生产者必须将数据安全地交给消费者。但是运行时两者的处理速度将是最大的问题。本模式是在生产者和消费者之间加入一个渠道，该参与者用以缓冲线程间的处理速度差。一般来说可能存在多个生产者和消费者，当各只有一个时，也称为Pipe模式。

渠道

class Channel {
    private final String[] buffer;
    private int tail;
    private int head;
    private int count;

    public Channel(int size) {
        this.buffer = new String[size];
        this.head = 0;
        this.tail = 0;
        this.count = 0;
    }

    public synchronized void put(String data) throws InterruptedException {
        while (count >= buffer.length)
            wait();
        buffer[tail] = data;
        tail = (tail + 1) % buffer.length;
        count++;
        System.out.print(Thread.currentThread().getName() + " puts " + data);
        showChannel();
        notifyAll();
    }

    public synchronized String take() throws InterruptedException {
        while (count <= 0)
            wait();
        String data = buffer[head];
        buffer[head] = null;
        head = (head + 1) % buffer.length;
        count--;
        System.out.print(Thread.currentThread().getName() + " takes " + data);
        showChannel();
        notifyAll();
        return data;
    }

    private void showChannel() {
        System.out.print(" Channel:");
        for (String data : buffer) {
            System.out.print(data + " ");
        }
        System.out.println();
    }
}

生产者

class Producer extends Thread {
    private final Channel channel;
    private static int id = 0;
    private final Random random;

    public Producer(String name, Channel channel, long seed) {
        super(name);
        this.channel = channel;
        this.random = new Random(seed);
    }

    @Override
    public void run() {
        try {
            while (true) {
                Thread.sleep(random.nextInt(1000));
                String data = "[Data No." + nextId() + " by " + getName() + "]";
                channel.put(data);
            }
        } catch (InterruptedException e) {

        }
    }

    private static synchronized int nextId() {
        return id++;
    }
}

消费者

class Consumer extends Thread {
    private final Channel channel;
    private final Random random;

    public Consumer(String name, Channel channel, long seed) {
        super(name);
        this.channel = channel;
        this.random = new Random(seed);
    }

    @Override
    public void run() {
        try {
            while (true) {
                String data = channel.take();
                Thread.sleep(random.nextInt(1000));
            }
        } catch (InterruptedException e) {

        }
    }
}

测试类

public class Main {

    public static void main(String[] args) {
        Channel channel = new Channel(3);
        new Producer("Producer-1", channel, 48395).start();
        new Producer("Producer-2", channel, 78749).start();
        new Producer("Producer-3", channel, 90759).start();
        new Consumer("Consumer-1", channel, 84395).start();
        new Consumer("Consumer-2", channel, 10394).start();
        new Consumer("Consumer-3", channel, 39486).start();
    }
}

测试结果

Producer-1 puts [Data No.0 by Producer-1] Channel:[Data No.0 by Producer-1] null null
Consumer-2 takes [Data No.0 by Producer-1] Channel:null null null
Producer-3 puts [Data No.1 by Producer-3] Channel:null [Data No.1 by Producer-3] null
Consumer-1 takes [Data No.1 by Producer-3] Channel:null null null
Producer-2 puts [Data No.2 by Producer-2] Channel:null null [Data No.2 by Producer-2]
Consumer-2 takes [Data No.2 by Producer-2] Channel:null null null
Producer-3 puts [Data No.3 by Producer-3] Channel:[Data No.3 by Producer-3] null null
Consumer-3 takes [Data No.3 by Producer-3] Channel:null null null
Producer-1 puts [Data No.4 by Producer-1] Channel:null [Data No.4 by Producer-1] null
Consumer-1 takes [Data No.4 by Producer-1] Channel:null null null
Producer-2 puts [Data No.5 by Producer-2] Channel:null null [Data No.5 by Producer-2]
Consumer-2 takes [Data No.5 by Producer-2] Channel:null null null
Producer-2 puts [Data No.6 by Producer-2] Channel:[Data No.6 by Producer-2] null null
Producer-2 puts [Data No.7 by Producer-2] Channel:[Data No.6 by Producer-2] [Data No.7 by Producer-2] null
Producer-1 puts [Data No.8 by Producer-1] Channel:[Data No.6 by Producer-2] [Data No.7 by Producer-2] [Data No.8 by Producer-1]
Consumer-3 takes [Data No.6 by Producer-2] Channel:null [Data No.7 by Producer-2] [Data No.8 by Producer-1]
Producer-2 puts [Data No.9 by Producer-2] Channel:[Data No.9 by Producer-2] [Data No.7 by Producer-2] [Data No.8 by Producer-1]
Consumer-1 takes [Data No.7 by Producer-2] Channel:[Data No.9 by Producer-2] null [Data No.8 by Producer-1]
Producer-3 puts [Data No.10 by Producer-3] Channel:[Data No.9 by Producer-2] [Data No.10 by Producer-3] [Data No.8 by Producer-1]
Consumer-2 takes [Data No.8 by Producer-1] Channel:[Data No.9 by Producer-2] [Data No.10 by Producer-3] null
Producer-2 puts [Data No.11 by Producer-2] Channel:[Data No.9 by Producer-2] [Data No.10 by Producer-3] [Data No.11 by Producer-2]
Consumer-1 takes [Data No.9 by Producer-2] Channel:null [Data No.10 by Producer-3] [Data No.11 by Producer-2]
Producer-1 puts [Data No.12 by Producer-1] Channel:[Data No.12 by Producer-1] [Data No.10 by Producer-3] [Data No.11 by Producer-2]
Consumer-3 takes [Data No.10 by Producer-3] Channel:[Data No.12 by Producer-1] null [Data No.11 by Producer-2]
Producer-3 puts [Data No.13 by Producer-3] Channel:[Data No.12 by Producer-1] [Data No.13 by Producer-3] [Data No.11 by Producer-2]
Consumer-1 takes [Data No.11 by Producer-2] Channel:[Data No.12 by Producer-1] [Data No.13 by Producer-3] null
。。。。。。

此处下载源代码

chenkkkabc 2009-06-04 12:35 发表评论