多线程程序设计学习（13）Active Object pattern

Active Object[接收异步消息的对象]

一:Active Object的参与者
--->客户端线程（发起某种操作请求处理）
--->代理角色（工头）
--->实际执行者（工人）
--->主动对象接口(工人和工头)
--->生产端线程（加工产品的线程）
--->存放生产请求的队列（存放请求的队列）
--->请求实例化（将方法的启动和执行分离的实例化包含）
--->订单
--->产品
--->订单产品的共同接口

二:Active Object模式什么时候使用
--->大型模式，适合处理大并发量的业务场景

三：Active Object思考
--->
四进阶说明        
--->

Active Object例子
工厂大量需要制造文字

一：订单和产品的接口

 package com.yeepay.sxf.thread12;
 /**
  * 订单和产品的接口
  * @author sxf
  *
  */
 public abstract class Result {
     //获取结果的方法
     public abstract Object getResultValue();

 }

二：订单类

 package com.yeepay.sxf.thread12;
 /**
  * 订单类
  * @author sxf
  *
  */
 public class FutureResult extends Result{
     //真正的产品
     private Result result;
     //产品是否生产好
     private boolean ready=false;

     //供生产线程使用，将生产好的产品放入订单
     public synchronized void setResult(Result result){
         this.result=result;
         this.ready=true;
         notifyAll();
     }

     //从订单里获取真正的产品结果
     @Override
     public synchronized Object getResultValue() {
         while(!ready){
             try {
                 wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         return result.getResultValue();
     }

 }

三：产品类

 package com.yeepay.sxf.thread12;

 /**
  * 产品类
  * @author sxf
  *
  */
 public class RealResult extends Result {
     private final Object resultValue;

     //制造产品的方法
     public RealResult(Object resultValue) {
         // TODO Auto-generated constructor stub
          this.resultValue=resultValue;
      }

     //获得产品
     @Override
     public Object getResultValue() {

         return resultValue;
     }

 }

四：工头和工人的接口

 package com.yeepay.sxf.thread12;

 /**
  * 工头和工人的接口
  * @author sxf
  *
  */
 public interface ActiveObject {
     //制造字符串
     public abstract Result makeString(int count,char fillchar);

     //显示字符串
     public abstract void displayString(String string);

 }

五:工头类

 package com.yeepay.sxf.thread12;

 /**
  * 发起制作操作的代理（工头）
  * @author sxf
  *
  */
 public class Poxy implements ActiveObject{
     //制造操作的线程
     private final SchedulerTHread schedulerTHread;
     //制造操作的工人
     private final Servant servant;
     //构造器
     public Poxy(SchedulerTHread schedulerTHread,Servant servant){
         this.schedulerTHread=schedulerTHread;
         this.servant=servant;
     }

     /**
      * 发起制造操作（开启制造操作的单据，并将制造原材料和制造工人打包，放入制造线程的队列中）
      */
     @Override
     public Result makeString(int count, char fillchar) {
         //制作一张订单
         FutureResult future=new FutureResult();
         //将原材料和工人和订单放入队列
         schedulerTHread.Invoke(new MakeStringRequset(servant, future, count, fillchar));
         //返回订单
         return future;
     }

     /**
      * 查看字符串
      */
     @Override
     public void displayString(String string) {
         //这个制造不需要订单
         schedulerTHread.Invoke(new DisplayStringRequest(servant, string));
     }

 }

六：工人类

 package com.yeepay.sxf.thread12;
 /**
  * 执行者（工人）
  * @author sxf
  *
  */

 public class Servant implements ActiveObject {

     /**
      * 生产字符串
      */
     @Override
     public Result makeString(int count, char fillchar) {
         char[] buffer=new char[count];
         for(int i=0;i<count;i++){
             buffer[i]=fillchar;
             try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         return new RealResult(buffer.toString());
     }

     /**
      * 打印字符串
      */
     @Override
     public void displayString(String string) {
         System.out.println("Servant.displayString()"+string);
         try {
             Thread.sleep(10);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }

 }

七：工作请求抽象的类

 package com.yeepay.sxf.thread12;
 /**
  * 执行请求的实例（工人，订单，原材料）
  * @author sxf
  *
  */
 public  abstract class MethodRequest {
     //工人
     protected final Servant servant;
     //订单
     protected final FutureResult future;

     protected MethodRequest(Servant servant,FutureResult future) {
         this.servant=servant;
         this.future=future;
     }
     //工人的具体操作
     public abstract void execute();
 }

八：制造文字的请求

 package com.yeepay.sxf.thread12;
 /**
  * 制造字符串请求实例
  * 其做用：将制造的发起者和制造的执行者分离。
  * ==》方法的启动和方法的执行进行分离
  * ==》分离的本质：（1）启动者将执行请求转换成实例（原材料，执行者，订单）
  *                               （2）执行者用原材料生产完产品，将产品存入订单，供发起者使用
  * @author sxf
  *
  */
 public class MakeStringRequset extends MethodRequest{
     private final int count;
     private final char fillchar;
     //构造器（制造工人，订单，产品原材料）
     public MakeStringRequset(Servant servant,FutureResult futureResult,int count,char fillchar) {
         super(servant, futureResult);
         this.count=count;
         this.fillchar=fillchar;
     }

     @Override
     public void execute() {
         //制造工人制造出产品
         RealResult realResult=(RealResult) servant.makeString(count, fillchar);
         //再将产品放入订单
         future.setResult(realResult);
     }

 }

九：打印文字的请求

 package com.yeepay.sxf.thread12;
 /**
  * 打印字符串的请求实例
  * @author sxf
  *
  */
 public class DisplayStringRequest extends MethodRequest{
     //打印原材料
     private final String string;
     public DisplayStringRequest(Servant servant,String string){
         super(servant, null);
         this.string=string;
     }
     //执行打印的方法
     @Override
     public void execute() {
         servant.displayString(string);
     }

 }

十：十：客户线程（1）（发起制造字符串请求的线程）

 package com.yeepay.sxf.thread12;

 /**
  * 发起制造字符串请求的线程
  * @author sxf
  *
  */
 public class MakerClientThread implements Runnable{
     //代理类（工头）
     private final ActiveObject activeObject;
     //生产原材料
     private final char fillChar;

     public MakerClientThread(ActiveObject activeObject,char fillChar) {
         this.activeObject=activeObject;
         this.fillChar=fillChar;
     }

     @Override
     public void run() {
         for(int i=0;true;i++){
             //（工头）发起制造，得到订单
             Result result=activeObject.makeString(i, fillChar);
             //忙别的事情
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             //从订单中获取产品结果
             String value=(String) result.getResultValue();
             //打印产品
             System.out.println(Thread.currentThread().getName()+"=>value:["+value+"]");
         }

     }

 }

十一：客户线程（2）发起打印字符串的请求线程

 package com.yeepay.sxf.thread12;
 /**
  * 发起打印字符串请求的线程
  * @author sxf
  *
  */
 public class DisplayClientThread implements Runnable{
     //工头
     private final ActiveObject activeObject;

     public DisplayClientThread(ActiveObject activeObject){
         this.activeObject=activeObject;
     }

     @Override
     public void run() {
         for(int i=0;true;i++){
             //打印原材料
             String string=Thread.currentThread().getName()+"  "+i;
             //工头进行找人打印
             activeObject.displayString(string);
             try {
                 Thread.sleep(200);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }

     }

 }

十二：生产线程

 package com.yeepay.sxf.thread12;

 /**
  * 制造线程（制造原材料==>原材料+工人）
  * @author sxf
  *
  */
 public class SchedulerTHread implements Runnable{
     //制造线程中的队列
     private final ActivationQueue activatonQueue;
     public SchedulerTHread(ActivationQueue  activationQueue) {
         this.activatonQueue=activationQueue;
     }

     //发起制造的线程，调用该方法，该方法是将制造请求（原材料+工人），放入队列
     public void Invoke(MethodRequest request){
         activatonQueue.putRequest(request);
     }

     //制造线程体
     @Override
     public void run() {
         while(true){
             //从队列中取出制造请求
             MethodRequest request=activatonQueue.takeRequest();
             //制造请求被执行
             request.execute();
         }

     }

 }

十三：客户线程和生产线程的队列

 package com.yeepay.sxf.thread12;

 /**
  * 队列
  * @author sxf
  *
  */
 public class ActivationQueue {
     private static final int MAX_METHOD_REQUEST=100;
     private final MethodRequest[] requestQueue;
     private int tail;//下一个put Request的地方
     private int head;//下一个take Request的地方
     private int countRequest;//request的数量

     public ActivationQueue() {
         this.requestQueue=new MethodRequest[MAX_METHOD_REQUEST];
         this.head=0;
         this.tail=0;
         this.countRequest=0;
     }

     //放入请求
     public synchronized void putRequest(MethodRequest request){
         while(countRequest>=requestQueue.length){
             try {
                 wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         requestQueue[tail]=request;
         //计算下一个放请求的位置
         tail=(tail+1)%requestQueue.length;
         //请求数加1
         countRequest++;
         //唤醒其他线程
          notifyAll();
     }

     //取出请求
     public synchronized MethodRequest takeRequest(){
         while(countRequest<=0){
             try {
                 wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         //取出
         MethodRequest methodRequest=requestQueue[head];
         //计算下一个取出请求的位置
         head=(head+1)%requestQueue.length;
         //请求数减去1
         countRequest--;
         //唤醒其他线程
         notifyAll();
         return methodRequest;
     }
 }

十四：产生工头的工厂类

 package com.yeepay.sxf.thread12;

 /**
  * 工头对象的工厂类
  * @author sxf
  *
  */
 public class ActiveObjectFactory {

     //生产工头的对象
     public static ActiveObject createActiveObject(){
         //执行制造操作（工人）
         Servant servant=new Servant();
         //存放制造请求实例
         ActivationQueue queue=new ActivationQueue();
         //制造操作的线程
         SchedulerTHread schedulerTHread=new SchedulerTHread(queue);
         //发起制造动作(工头)
         Poxy poxy=new Poxy(schedulerTHread, servant);
         //启动制造操作的线程
         new Thread(schedulerTHread).start();
         return poxy;
     }
 }

十五：测试类

 package com.yeepay.sxf.thread12;
 /**
  * 测试类
  * @author sxf
  *
  */
 public class Test {

     public static void main(String[] args) {
         ActiveObject activeObject=ActiveObjectFactory.createActiveObject();
         new Thread(new  MakerClientThread(activeObject, 's')).start();;
         new Thread(new DisplayClientThread(activeObject)).start();

     }
 }