BlogJava-Java天空任我翱翔-随笔分类-Design Patterns

多线程设计模式总结

persister — Sun, 31 Jan 2010 07:26:00 GMT

Java多线程设计模式，帮助多线程功能提高质量，降低学习成本。主要的Pattern如下：
1.Single Threaded Execution Pattern 多个线程共享一个实例，这样的话，多个线程都
擅自改动实例的状态，实例会丧失安全性。这种情况可以通过Java的关键词synchronized来解决。如多个人
通过一个gate时，只能一个个通过，那么可以如下的方式：
public synchronized void pass(String name){
   this.name = name;
}
synchronized方法的性能比普通的方法低，所以降低减少使用。
JDK中很多方法是synchronized，可以安全使用，很多为了性能是没有同步。为了提高性能可以考虑使用 Immutable Pattern
2.Immutable Pattern 多个线程共享一个实例，但是实例的状态不会改变，可以提供throughput，但必须保证
不变形（实例的状态不会改变）。需要使用private，final等来支持。
3.Guarded Suspension Pattern 多个线程共享一个实例，这样的话，多个线程都
擅自改动实例的状态，实例会丧失安全性。当实例的状态不恰当时，就要求线程等待到合适的状态，以“警戒条   件”来表示实例的“适当的状态”。如果警戒条件一直不成立，线程会永远等待下去，会使程序丧失生命性。Java   中用while循环来测试警戒条件，使用wait方法让线程等待，并使用notify/notifyAll通知警戒条件的改变。
检   验、修改警戒条件是，会使用Single Threaded Execution Pattern。Pattern的例子如下：
public class RequestQueue{

      private final LinkedList queue = new LinkedList();
      public synchronized Request getRequest(){
   while(queue.size() <= 0){   //警戒条件
         try{
       wait();
          }catch(InterruptedException e){}
   }
   return (Request)queue.removeFirst();
      }
      public synchronized void putRequest(Request request){
       queue.addLast(request);
       notifyAll();

      }

}

以上使用Queue的客户端和服务器代码里面非常干净，没有多线程的东西，代码复用性很好。
当警戒条件不成立时想要马上退出，就使用Balking Pattern
4.Balking Pattern 一直等待安全的时机，会使程序的响应性降低。Java语言中，检验警戒条件时要使用if语句
，当要balk时，可使用return退出方法，或者throw抛出异常。
public class Data {
    private String filename;    //修改是的名字
    private String content;     // 资料的内容
    private boolean changed;    //修改后的内容还没存储的话，值为true

    public Data(String filename, String content) {
        this.filename = filename;
        this.content = content;
        this.changed = true;
    }

    // 修改资料内容
    public synchronized void change(String newContent) {
        content = newContent;
        changed = true;
    }

    // 若有资料修改，就存储到挡安里
    public synchronized void save() throws IOException {
        if (!changed) {
            System.out.println(Thread.currentThread().getName() + " balks");
            return; //没有就退出
        }
        doSave();
        changed = false;
    }

    // 实际资料储存到挡案里用的方法
    private void doSave() throws IOException {
        System.out.println(Thread.currentThread().getName() + " calls doSave, content = " + content);
        Writer writer = new FileWriter(filename);
        writer.write(content);
        writer.close();
    }
}

5.Producer-Consumer Pattern 当Producer参与者与Consumer参与者处理的速度不同时，速度慢的会扯速度快的
后腿，而降低程序的throughput。解决的办法就是在两者之间，加上中继用的Channel参与者。并让Channel
参与者存放多条数据，这样就可以缓冲Producer和Consumer之间处理速度的差异。这个模式使用了Guarded
Suspension Pattern。

public class Table {
    private final String[] buffer;
    private int tail; /下一个放put的地方
    private int head; //下一个放的take地方
    private int count; // buffer内的蛋糕数
    public Table(int count) {
        this.buffer = new String[count];
        this.head = 0;
        this.tail = 0;
        this.count = 0;
    }
    // 放置蛋糕
    public synchronized void put(String cake) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + " puts " + cake);
        while (count >= buffer.length) {
            wait();
        }
        buffer[tail] = cake;
        tail = (tail + 1) % buffer.length;
        count++;
        notifyAll();
    }
    // 取得蛋糕
    public synchronized String take() throws InterruptedException {
        while (count <= 0) {
            wait();
        }
        String cake = buffer[head];
        head = (head + 1) % buffer.length;
        count--;
        notifyAll();
        System.out.println(Thread.currentThread().getName() + " takes " + cake);
        return cake;
    }
}

6.Read-Write Lock Pattern 多个线程共享一个实例，如进程之间不进行共享胡扯，会丧失安全性。
但使用Single Threaded Execution Pattern会使程序throughput降低。解决的方法就是将控制reader参与者的    锁定与控制writer参与者的锁定分开，加入ReadWriteLock参与者，以提供两种不同的锁定。

public final class ReadWriteLock {
    private int readingReaders = 0; // (A)...实际正在读取的执行绪数量
    private int waitingWriters = 0; // (B)...正在等待写入的执行绪数量
    private int writingWriters = 0; // (C)...实际正在写入的执行绪数量
    private boolean preferWriter = true; // 写入优先的话，值为true

    public synchronized void readLock() throws InterruptedException {
        while (writingWriters > 0 || (preferWriter && waitingWriters > 0)) {
            wait();
        }
        readingReaders++;                       // (A)实际正在读取的线程数量加1
    }

    public synchronized void readUnlock() {
        readingReaders--;                       // (A)实际正在读取的线程数量减1
        preferWriter = true;
        notifyAll();
    }

    public synchronized void writeLock() throws InterruptedException {
        waitingWriters++;                       // (B)正在等待写入的线程数量加1
        try {
            while (readingReaders > 0 || writingWriters > 0) {
                wait();
            }
        } finally {1
          waitingWriters--;                   // (B)正在等待写入的线程数量减1
        }
        writingWriters++;                       // (C)实际正在写入的线程数量加1
    }

    public synchronized void writeUnlock() {
        writingWriters--;                       // (C)实际正在写入的线程数量减
        preferWriter = false;
        notifyAll();
    }
}

public class Data {
    private final char[] buffer;
    private final ReadWriteLock lock = new ReadWriteLock();
    public Data(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) {
        }
    }
}

7.Thread-Per-Message Pattern 在方法的属性处理完成之前，控制权不会从Host参与者退出。如果方法的处理
属性很话费时间，程序的响应性能会降低。解决的方式就在Host的参与者里，启动新的线程，并且将该方法应    该进行的工作交给这个心的线程，这样Client参与者的线程可以继续执行下一个操作，这样做，不用更改    Client参与者的程序代码，并能提高程序的响应性。想节省启动线程所花费的时间，可以使用Worker Thread    Pattern。
public class Host {
    private final Helper helper = new Helper();
    public void request(final int count, final char c) {
        System.out.println("    request(" + count + ", " + c + ") BEGIN");
        new Thread() {
            public void run() {
                helper.handle(count, c);
            }
        }.start();
        System.out.println("    request(" + count + ", " + c + ") END");
    }
}

8.Worker Thread Pattern 如果方法的处理属性很花时间，程序的响应性会降低。为了提供响应性，而启动新
的线程来处理方法时，启动线程所花的时间又会降低throughput。另外当送出的请求太多时，会启动
过多的线程，这会使承载量变差。
public class Channel {
    private static final int MAX_REQUEST = 100;
    private final Request[] requestQueue;
    private int tail; // 下一个putRequest的地方
    private int head; // 下一个takeRequest的地方
    private int count; // Request的数量

    private final WorkerThread[] threadPool;

    public Channel(int threads) {
        this.requestQueue = new Request[MAX_REQUEST];
        this.head = 0;
        this.tail = 0;
        this.count = 0;

        threadPool = new WorkerThread[threads];
        for (int i = 0; i < threadPool.length; i++) {
            threadPool[i] = new WorkerThread("Worker-" + i, this);
        }
    }
    public void startWorkers() {
        for (int i = 0; i < threadPool.length; i++) {
            threadPool[i].start();
        }
    }
    public synchronized void putRequest(Request request) {
        while (count >= requestQueue.length) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        requestQueue[tail] = request;
        tail = (tail + 1) % requestQueue.length;
        count++;
        notifyAll();
    }
    public synchronized Request takeRequest() {
        while (count <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        Request request = requestQueue[head];
        head = (head + 1) % requestQueue.length;
        count--;
        notifyAll();
        return request;
    }
}

9.Future Pattern 当Client会将工作委托给其他线程，而Client参与者希望得到处理的结果。将工作委托给
别人时，如果又等待执行结果，会使响应性降低。
public class FutureData implements Data {
    private RealData realdata = null;
    private boolean ready = false;
    public synchronized void setRealData(RealData realdata) {
        if (ready) {
            return;     // balk
        }
        this.realdata = realdata;
        this.ready = true;
        notifyAll();
    }
    public synchronized String getContent() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        return realdata.getContent();
    }
}

附多线程程序的评价标准
1、安全性——不损坏对象对象损坏是指对象的状态不符合设计师的原意，通常是获取对象的状态值并非预期值。
2、生存性——进行必要的处理也许不是现在，但是一定会进行必要的处理，如果程序安全了，但是有些必要的处理得不到操作，那么这个多线程程序也是不合格的。
3、复用性——可再利用类写多线程程序，如果能够将多线程的共享和互斥结构隐藏在类里面，这就是一个高度可复印的程序。
4、性能——能快速大量处理主要表现在吞吐量（Throughput）即一定时间内能完成的处理量，能完成的处理量越多，表示数据吞吐量越大；容量（Capacity）指可同时处理的数量；响应性（Responsiveness）指从发出请求到收到响应的时间，时间越短，响应性越高。
5、伸缩性（Scalability）等

前两个是必要条件，后面几个是程序质量的描述

persister 2010-01-31 15:26 发表评论

java多线程设计模式:wait/notify机制

persister — Thu, 03 Dec 2009 06:45:00 GMT

通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。
如果图片还没有下载完，displayThread能暂停，当downloadThread完成了任务后，再通知displayThread“图片准备完毕，能显示了”，这时，displayThread继续执行。　　
以上逻辑简单的说就是：如果条件不满足，则等待。
当条件满足时，等待该条件的线程将被唤醒。
在Java中，这个机制的实现依赖于wait/notify。等待机制和锁机制是密切关联的。
例如：　　

1 synchronized(obj)
2 {　　
3 while(!condition)
4 {
5 　　obj.wait();　　
6
7 }　　
8 obj.doSomething();　　
9 }　

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。　　在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就能唤醒线程A：

1 synchronized(obj)
2 {　　
3 condition = true;　　
4 obj.notify();　　
5 }　

需要注意的概念是：　　
# 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。　　

# 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。　　

# 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。　　
# 如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。　　
# obj.notifyAll()则能全部唤醒A1,A2,A3，不过要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。　　
# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，不过仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

persister 2009-12-03 14:45 发表评论

Visitor设计模式的理解

persister — Tue, 31 Jul 2007 03:32:00 GMT

Visitor模式，在不修改已有程序结构的前提下，通过添加额外的“访问者”来完成对已有代码功能的提升。
Visitor模式包括以下几个元素：

1) 访问者接口（Visitor）：声明一个访问接口，定义visit接口，有几个元素就定义几个接口方法。接口方法的参数标识了具体访问元素角色，也就是说参数是一个具体类。这个地方也是Visitor的不足，

2) 具体访问者（Concrete Visitor）：实现Visitor接口

3) 元素接口（Element）：定义一个accept方法，它以访问者接口为参数，这里不是具体的访问者，即不知道具体的访问者。

4) 具体元素（Concrete Element）：实现元素（Element）接口中accept方法，控制访问的流程。

5) 对象结构（Object Structure）：这是使用Visitor模式必须的角色。它要具备以下特征：能枚举它的元素；可以提供一个高层的接口允许访问者访问它的元素；可以是一个集合，如一个列表或一个无序集合。

类图如下：

具体代码：

public interface Visitor
{
public void visitCollection(Collection collection);
public void visitString(String string);
public void visitFloat(Float float);
}

public class ConcreteVisitor1 implements Visitor
{
//在本方法中，我们实现了对Collection的元素的成功访问
　　 public void visitCollection(Collection collection) {
　　 Iterator iterator = collection.iterator()
　　 while (iterator.hasNext()) {
　　　　 Object o = iterator.next();
　　　　 if (o instanceof Visitable)
　　　　　　 ((Visitable)o).accept(this);
　　 }

public void visitString(String string) {
　　 System.out.println("'"+string+"'");
}

public void visitFloat(Float float) {
　　 System.out.println(float.toString()+"f");
}
}

public interface Visitable
{
public void accept(Visitor visitor);
}

public class StringElement implements Visitable
{
private String value;
public ConcreteElement(String string) {
　　 value = string;
}
//定义accept的具体内容这里是很简单的一句调用
　　 public void accept(Visitor visitor) {
　　 visitor.visitString(this);
}
}

public class FloatElement implements Visitable
{
private Float value;
public ConcreteElement(Float f) {
　　 value = f;
}
//定义accept的具体内容这里是很简单的一句调用
　　 public void accept(Visitor visitor) {
　　 visitor.visitFloat(this);
}
}

总结：
1、元素接口和元素类都是依赖Visitor接口，而不是具体实现类，很好的实现了解耦。如果有一个新的元素欢迎Visitor参观，只需要实现Visitable接口，并实现accept方法即可，都不牵涉具体的Visitor。

2、Visitor接口则不然，它依赖具体的元素，也就是说如果元素的类型发生变化如增加一个元素类型，那么Visitor接口和具体实现类都必须大改，这个是Visitor模式严重的缺陷。

3、Visitor模式名副其实，好比旅行社、游客和景点的关系。旅行社就是Visitor接口，这次路线都需要参观哪些景点通常是固定的（接口固定，如果要改变行程，通常很麻烦）；游客就这些景点，旅行社给你安排两个小时,你想自己怎么玩都行；景点则以不变应万变。这个比如也许有些不恰当，不过有助于理解这个模式。

persister 2007-07-31 11:32 发表评论

BlogJava-Java天空 任我翱翔-随笔分类-Design Patterns

多线程设计模式总结

java多线程设计模式:wait/notify机制

Visitor设计模式的理解

BlogJava-Java天空任我翱翔-随笔分类-Design Patterns