C++博客-mysileng-随笔分类-设计模式http://www.cppblog.com/mysileng/category/20569.htmlzh-cnSat, 22 Jun 2013 04:48:35 GMTSat, 22 Jun 2013 04:48:35 GMT60Reactor模式 (转)http://www.cppblog.com/mysileng/archive/2013/01/17/197337.html鑫龙鑫龙Thu, 17 Jan 2013 05:38:00 GMThttp://www.cppblog.com/mysileng/archive/2013/01/17/197337.htmlhttp://www.cppblog.com/mysileng/comments/197337.htmlhttp://www.cppblog.com/mysileng/archive/2013/01/17/197337.html#Feedback0http://www.cppblog.com/mysileng/comments/commentRss/197337.htmlhttp://www.cppblog.com/mysileng/services/trackbacks/197337.htmlReactor这个词译成汉语还真没有什么合适的，很多地方叫反应器模式，但更多好像就直接叫reactor模式了，其实我觉着叫应答者模式更好理解一些。通过了解，这个模式更像一个侍卫，一直在等待你的召唤，或者叫召唤兽。

 

并发系统常使用reactor模式，代替常用的多线程的处理方式，节省系统的资源，提高系统的吞吐量。

 

先用比较直观的方式来介绍一下这种方式的优点，通过和常用的多线程方式比较一下，可能更好理解。

以一个餐饮为例，每一个人来就餐就是一个事件，他会先看一下菜单，然后点餐。就像一个网站会有很多的请求，要求服务器做一些事情。处理这些就餐事件的就需要我们的服务人员了。

 

在多线程处理的方式会是这样的：

一个人来就餐，一个服务员去服务，然后客人会看菜单，点菜。 服务员将菜单给后厨。

二个人来就餐，二个服务员去服务……

五个人来就餐，五个服务员去服务……

 

这个就是多线程的处理方式，一个事件到来，就会有一个线程服务。很显然这种方式在人少的情况下会有很好的用户体验，每个客人都感觉自己是VIP，专人服务的。如果餐厅一直这样同一时间最多来5个客人，这家餐厅是可以很好的服务下去的。

 

来了一个好消息，因为这家店的服务好，吃饭的人多了起来。同一时间会来10个客人，老板很开心，但是只有5个服务员，这样就不能一对一服务了，有些客人就要没有人管了。老板就又请了5个服务员，现在好了，又能每个人都受VIP待遇了。

 

越来越多的人对这家餐厅满意，客源又多了，同时来吃饭的人到了20人，老板高兴不起来了，再请服务员吧，占地方不说，还要开工钱，再请人就攒不到钱了。怎么办呢？老板想了想，10个服务员对付20个客人也是能对付过来的，服务员勤快点就好了，伺候完一个客人马上伺候另外一个，还是来得及的。综合考虑了一下，老板决定就使用10个服务人员的线程池啦~~~

 

但是这样有一个比较严重的缺点就是，如果正在接受服务员服务的客人点菜很慢，其他的客人可能就要等好长时间了。有些火爆脾气的客人可能就等不了走人了。

 

Reactor如何处理这个问题呢：

老板后来发现，客人点菜比较慢，大部服务员都在等着客人点菜，其实干的活不是太多。老板能当老板当然有点不一样的地方，终于发现了一个新的方法，那就是：当客人点菜的时候，服务员就可以去招呼其他客人了，等客人点好了菜，直接招呼一声“服务员”，马上就有个服务员过去服务。嘿嘿，然后在老板有了这个新的方法之后，就进行了一次裁员，只留了一个服务员！这就是用单个线程来做多线程的事。

 

实际的餐馆都是用的Reactor模式在服务。一些设计的模型其实都是从生活中来的。

 

Reactor模式主要是提高系统的吞吐量，在有限的资源下处理更多的事情。

 

在单核的机上，多线程并不能提高系统的性能，除非在有一些阻塞的情况发生。否则线程切换的开销会使处理的速度变慢。就像你一个人做两件事情，1、削一个苹果。2、切一个西瓜。那你可以一件一件的做，我想你也会一件一件的做。如果这个时候你使用多线程，一会儿削苹果，一会切西瓜，可以相像究竟是哪个速度快。这也就是说为什么在单核机上多线程来处理可能会更慢。

 

但当有阻碍操作发生时，多线程的优势才会显示出来，现在你有另外两件事情去做，1、削一个苹果。2、烧一壶开水。我想没有人会去做完一件再做另一件，你肯定会一边烧水，一边就把苹果削了。

 


转自:http://daimojingdeyu.iteye.com/blog/828696



鑫龙 2013-01-17 13:38 发表评论
]]>Java Observable 模式(转)http://www.cppblog.com/mysileng/archive/2012/09/26/192077.html鑫龙鑫龙Wed, 26 Sep 2012 06:30:00 GMThttp://www.cppblog.com/mysileng/archive/2012/09/26/192077.htmlhttp://www.cppblog.com/mysileng/comments/192077.htmlhttp://www.cppblog.com/mysileng/archive/2012/09/26/192077.html#Feedback0http://www.cppblog.com/mysileng/comments/commentRss/192077.htmlhttp://www.cppblog.com/mysileng/services/trackbacks/192077.html一、Observer模式的意图：

                在对象的内部状态发生变化时，自动通知外部对象进行响应。

二、Observer模式的构成：

               ·被观察者：内部状态有可能被改变，而且又需要通知外部的对象

               ·观察者：需要对内部状态的改变做出响应的对象

三、Observer模式的Java实现：

                Java的API中已经为我们提供了Observer模式的实现。具体由java.util.Observable类和java.util.Observer接口完成。

                前者有两个重要的方法：

                       ·setChanged：设置内部状态为已改变

                       ·notifyObservers(Object obj)：通知观察者所发生的改变，参数obj是一些改变的信息

                后者有一个核心方法：

                       ·update(Object obj)：相应被观察者的改变，其中obj就是被观察者传递过来的信息，该方法会在notifyObservers被调用时自动调用。

              下面是Observer模式的实现过程：

                     ·创建一个被观察者，继承java.util.Observable

                     ·创建一个观察者，实现java.util.Observer接口

                    · 注册观察着，调用addObserver(Observer observer)

                    ·在被观察者改变对象内部状态的地方，调用setChanged()方法，然后调用notifyObservers(Object)方法，通知被观察者

                   ·在观察者的update(Object)方法中，对改变做出响应。

四、Observer模式的好处：

                 1.Observer模式的优点：

                       ·被观察者只需要知道谁在观察它，无需知道具体的观察细节

                       ·被观察者一旦发生变化，只需要通过广播的方式告知观察者，至于消息如何到达则不需知道。这样的话无疑消除了被观察者和观察者之间通信的硬编码

                       ·当一个被观察者同时被多个观察着观察时，观察者可以只选择自己感兴趣的事件，而忽略其它的事件
   
                      ·多个观察者组合起来可以形成一个观察链，如果一旦需要回滚多个操作，此时观察链可以发挥作用

                      ·观察者可以实时对被观察对象的变化做出响应，例如自动告警、中断运行等


                2.运用Observer模式可以

                     ·屏蔽线程间的通信机制：例如两个线程之间，主线程可以作为观察者，执行线程是被观察者。彼此之间只知道对方存在，但不知道之间通信的细节

                    ·消除硬编码：如果没有Observer模式，则只能采用回调的模式，或者在代码中显示地调用观察者

                    ·优化异常机制：特别适合在异常发生时向顶层监控，减少try-catch代码量

代码：

 

  1. public class Observable {      
  2.     private boolean changed = false;      
  3.     private Vector obs;      
  4.          
  5.     //创建被观察者时就创建一个它持有的观察者列表，注意，这个列表是需要同步的。      
  6.     public Observable() {      
  7.     obs = new Vector();      
  8.     }      
  9.      
  10.     /**    
  11.      * 添加观察者到观察者列表中去    
  12.      */     
  13.     public synchronized void addObserver(Observer o) {      
  14.         if (o == null)      
  15.             throw new NullPointerException();      
  16.     if (!obs.contains(o)) {      
  17.         obs.addElement(o);      
  18.     }      
  19.     }      
  20.      
  21.     /**    
  22.      * 删除一个观察者    
  23.      */     
  24.     public synchronized void deleteObserver(Observer o) {      
  25.         obs.removeElement(o);      
  26.     }      
  27.      
  28.     /**    
  29.      * 通知操作，即被观察者发生变化，通知对应的观察者进行事先设定的操作，不传参数的通知方法    
  30.      */     
  31.     public void notifyObservers() {      
  32.     notifyObservers(null);      
  33.     }      
  34.      
  35.     /**    
  36.      * 与上面的那个通知方法不同的是，这个方法接受一个参数，这个参数一直传到观察者里，以供观察者使用    
  37.      */     
  38.     public void notifyObservers(Object arg) {      
  39.           
  40.         Object[] arrLocal;      
  41.      
  42.     synchronized (this) {      
  43.         if (!changed)      
  44.                 return;      
  45.             arrLocal = obs.toArray();      
  46.             clearChanged();      
  47.         }      
  48.      
  49.         for (int i = arrLocal.length-1; i>=0; i--)      
  50.             ((Observer)arrLocal[i]).update(this, arg);      
  51.     }      
  52. }     
  53. public interface Observer {      
  54.     /**    
  55.      * This method is called whenever the observed object is changed. An    
  56.      * application calls an <tt>Observable</tt> object's    
  57.      * <code>notifyObservers</code> method to have all the object's    
  58.      * observers notified of the change.    
  59.      *    
  60.      * @param   o     the observable object.    
  61.      * @param   arg   an argument passed to the <code>notifyObservers</code>    
  62.      *                 method.    
  63.      */     
  64.     void update(Observable o, Object arg);      
  65. }      
  66. }     
  67. public class MailObserver implements Observer{      
  68.      
  69.     /**    
  70.      * 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者    
  71.      */     
  72.     public void update(Observable o, Object arg) {      
  73.         System.out.println("发送邮件的观察者已经被执行");      
  74.     }      
  75. }     
  76. public class JMSObserver implements Observer{      
  77.      
  78.     public void update(Observable o, Object arg) {      
  79.         System.out.println("发送消息给jms服务器的观察者已经被执行");      
  80.     }      
  81. }     
  82. public class Subject extends Observable{      
  83.           
  84.     /**    
  85.      * 业务方法，一旦执行某个操作，则通知观察者    
  86.      */     
  87.     public void doBusiness(){      
  88.         if (true) {      
  89.             super.setChanged();      
  90.         }      
  91.         notifyObservers("现在还没有的参数");      
  92.     }      
  93.      
  94.           
  95.     public static void main(String [] args) {      
  96.         //创建一个被观察者      
  97.         Subject subject = new Subject();      
  98.               
  99.         //创建两个观察者      
  100.         Observer mailObserver = new MailObserver();      
  101.         Observer jmsObserver = new JMSObserver();      
  102.               
  103.         //把两个观察者加到被观察者列表中      
  104.         subject.addObserver(mailObserver);      
  105.         subject.addObserver(jmsObserver);      
  106.               
  107.         //执行业务操作      
  108.         subject.doBusiness();      
  109.     }      
  110. }    

 

 



鑫龙 2012-09-26 14:30 发表评论
]]>