丁香婷婷亚洲六月综合色,国产偷国产偷亚洲高清日韩,亚洲AV成人无码网站

多线�E�设计模式�ȝ��

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

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

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

      }

}

以上使用Queue的客��L��和服务器代码里面非常�q�净�Q�没有多�U�程的东西，代码复用性很好�?br /> 当警戒条件不成立时想要马上退出，��׃��用Balking Pattern
4.Balking Pattern 一直等待安全的时机�Q�会使程序的响应性降低。Java语言中，��验警戒条件时要��用if语句
�Q�当要balk�Ӟ��可��用return退出方法，或者throw抛出异常�?br /> public class Data {
    private String filename;    //修改是的名字�?br />     private String content;     // 资料的内�?br />     private boolean changed;    //修改后的内容�q�没存储的话�Q��gؓ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;
    }

    // 若有资料修改�Q�就存储到挡安里
    public synchronized void save() throws IOException {
        if (!changed) {
            System.out.println(Thread.currentThread().getName() + " balks");
            return; //没有��退�?nbsp;
        }
        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参与者处理的速度不同�Ӟ��速度慢的会扯速度快的
后腿�Q�而降低程序的throughput。解决的办法��是在两者之��_��加上中��用的Channel参与者。�ƈ让Channel
参与者存攑֤�条数据，�q�样��可以缓冲Producer和Consumer之间处理速度的差异。这个模式��用了Guarded
Suspension Pattern�?br />
public class Table {
    private final String[] buffer;
    private int tail; /下一个放put的地�?
    private int head; //下一个放的take地方
    private int count; // buffer内的蛋糕�?br />     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();
    }
    // 取得蛋�p?br />     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 多个�U�程�׃�n一个实例，如进�E�之间不�q�行�׃�n胡扯�Q�会丧失安全性�?br /> 但��用Single Threaded Execution Pattern会�ɽE�序throughput降低。解决的�Ҏ��是��控制reader参与者的    锁定与控制writer参与者的锁定分开�Q�加入ReadWriteLock参与者，以提供两�U�不同的锁定�?br />
public final class ReadWriteLock {
    private int readingReaders = 0; // (A)...实际正在��d��的执行��A数量
    private int waitingWriters = 0; // (B)...正在�{�待写入的执行��A数量
    private int writingWriters = 0; // (C)...实际正在写入的执行��A数量
    private boolean preferWriter = true; // 写入优先的话�Q��gؓtrue

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

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

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

    public synchronized void writeUnlock() {
        writingWriters--;                       // (C)实际正在写入的线�E�数量减
        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参与者退出。如果方法的处理
属性很话费旉��Q�程序的响应性能会降低。解决的方式��在Host的参与者里�Q�启动新的线�E�，�q�且��该�Ҏ��?nbsp;   该进行的工作交给�q�个心的�U�程�Q�这样Client参与者的�U�程可以�l�箋执行下一个操作，�q�样做，不用更改    Client参与者的�E�序代码�Q��ƈ能提高程序的响应性。想节省启动�U�程所��p��的时��_��可以使用Worker Thread    Pattern�?br /> 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 如果�Ҏ��的处理属性很花时��_��E�序的响应性会降低。�ؓ了提供响应性，而启动新
的线�E�来处理�Ҏ��Ӟ��启动�U�程所��q��旉��又会降低throughput。另外当送出的请求太多时�Q�会启动
�q�多的线�E�，�q�会使承载量变差�?br /> public class Channel {
    private static final int MAX_REQUEST = 100;
    private final Request[] requestQueue;
    private int tail; // 下一个putRequest的地�?br />     private int head; // 下一个takeRequest的地�?br />     private int count; // Request的数�?br />
    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会将工作委托�l�其他线�E�，而Client参与者希望得到处理的�l�果。将工作委托�l?br /> 别�h�Ӟ��如果又等待执行结果，会��响应性降低�?br /> 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();
    }
}

附多�U�程�E�序的评��h��?br /> 1、安全性——不损坏对象对象损坏是指对象的状态不�W�合设计师的原意�Q�通常是获取对象的状态值�ƈ非预期倹{�?br /> 2、生存性——进行必要的处理也许不是现在�Q�但是一定会�q�行必要的处理，如果�E�序安全了，但是有些必要的处理得不到操作�Q�那么这个多�U�程�E�序也是不合格的�?br /> 3、复用性——可再利用类写多�U�程�E�序�Q�如果能够将多线�E�的�׃�n和互斥结构隐藏在�c�里面，�q�就是一个高度可复印的程序�?br /> 4、性能——能快速大量处�?主要表现在吞吐量�Q�Throughput�Q�即一定时间内能完成的处理量，能完成的处理量越多，表示数据吞吐量越大；定w��Q�Capacity�Q�指可同时处理的数量�Q�响应性（Responsiveness�Q�指从发��求到收到响应的时��_��旉��短�Q�响应性越高�?br /> 5、�׾~�性（Scalability�Q�等

前两个是必要条�g�Q�后面几个是�E�序质量的描�q?br />

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

java多线�E�设计模�?wait/notify机制

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

通常�Q�多�U�程之间需要协调工作。例如，��览器的一个显�C�图片的�U�程displayThread惌��执行昄��囄��的�Q务，必须�{�待下蝲�U�程 downloadThread��该囄��下蝲完毕�?br /> 如果囄��q�没有下载完�Q�displayThread能暂停，当downloadThread完成了�Q�? 后，再通知displayThread“囄��准备完毕�Q�能昄��?#8221;�Q�这�Ӟ��displayThread�l�箋执行。　　
以上逻辑��单的说就是：如果条�g不满��I��则等待�?br /> 当条件满��x��Q�等待该条�g的线�E�将被唤醒�?br /> 在Java中，�q�个机制的实��C��赖于wait/notify。等待机制和锁机制是密切兌��的�?br /> 例如�Q�　　

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

当线�E�A获得了obj锁后�Q�发现条件condition不满��I��无法�l�箋下一处理�Q�于是线�E�A��wait()。　　在另一�U�程B中，如果B更改了某些条�Ӟ��使得�U�程A的condition条�g满��了，��p��唤醒�U�程A�Q?br />

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

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

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

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

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

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

Visitor模式�Q�在不修改已有程序结构的前提下，通过��d��额外�?#8220;讉K��?#8221;来完成对已有代码功能的提升�?br /> Visitor模式包括以下几个元素�Q?br />
1) 讉K��者接口（Visitor�Q�：声明一个访问接口，定义visit接口�Q�有几个元素��定义几个接口方法。接口方法的参数标识了具体访问元素角�Ԍ��也就是说参数是一个具体类。这个地方也是Visitor的不��I��

2) 具体讉K��者（Concrete Visitor�Q�：实现Visitor接口

3) 元素接口�Q�Element�Q�：定义一个accept�Ҏ��Q�它以访问者接口�ؓ参数�Q�这里不是具体的讉K��者，即不知道具体的访问者�?br />
4) 具体元素�Q�Concrete Element�Q�：实现元素�Q�Element�Q�接口中accept�Ҏ��Q�控制访问的��程�?br />
5) 对象�l�构�Q�Object Structure�Q�：�q�是使用Visitor模式必须的角艌Ӏ�它要具备以下特征：能枚丑֮�的元素；可以提供一个高层的接口允许讉K��者访问它的元素；可以是一个集合，如一个列表或一个无序集合�?br />
�c�d��如下�Q?br />

具体代码�Q?br />

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

public class ConcreteVisitor1 implements Visitor
{
//在本�Ҏ��中，我们实现了对Collection的元素的成功讉K��
　　 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的具体内�?nbsp;�q�里是很��单的一句调�?/span>
　　 public void accept(Visitor visitor) {
　　 visitor.visitString(this);
}
}

public class FloatElement implements Visitable
{
private Float value;
public ConcreteElement(Float f) {
　　 value = f;
}
//定义accept的具体内�?nbsp;�q�里是很��单的一句调�?/span>
　　 public void accept(Visitor visitor) {
　　 visitor.visitFloat(this);
}
}

�ȝ��Q?br /> 1、元素接口和元素�c�都是依赖Visitor接口�Q�而不是具体实现类�Q�很好的实现了解耦。如果有一个新的元素欢�q�Visitor参观�Q�只需要实现Visitable接口�Q��ƈ实现accept�Ҏ��卛_��Q�都不牵涉具体的Visitor�?br />
2、Visitor接口则不�Ӟ��它依赖具体的元素�Q�也��是说如果元素的�c�d��发生变化如增加一个元素类型，那么Visitor接口和具体实现类都必��d��改，�q�个是Visitor模式严重的缺陗��?br />
3、Visitor模式名副其实�Q�好比旅行社、游客和景点的关�p�R��旅行社��是Visitor接口�Q�这�ơ�\�U�K��需要参观哪些景炚w��常是固定的�Q�接口固定，如果要改变行�E�，通常很麻烦）�Q�游客就�q�些景点�Q�旅行社�l�你安排两个��时,你想自己怎么玩都行；景点则以不变应万变。这个比如也许有些不恰当�Q�不�q�有助于理解�q�个模式�?br />

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