Java多线程ActiveObject模式

概述

接受异步消息的主动对象。
Java的java.lang.Thread类的实例就是一种主动对象。
主动对象可以从外部接收和处理异步消息并根据需要返回处理结果。
Active Object模式中的主动对象会通过自己特有的线程在合适的时机处理从外部接收到的异步消息。
Active Object模式有时也称Actor模式。

示例程序

 使用的类
 - Main   测试程序行为的类
 - MakerClientThread   发出“生成字符串”请求的线程
 - DisplayClientThread  发出“显示字符串”请求的线程
 - ActiveObject  定义“主动对象”的接口（API）的接口
 - ActiveObjectFactory  创建“主动对象”的类
 - Proxy   将方法调用转换为MethodRequest对象的类（实现了ActiveObject的接口）
 - SchedulerThread  调用execute 方法处理 MethodRequest 对象的类
 - ActivationQueue  按顺序保存MethodRequest对象的类
 - MethodRequest  表示请求的抽象类
 - MakeStringRequest  makeString方法（生成字符串）对应的类。MethodRequest类的子类
 - DisplayStringRequest  displayString方法（显示字符串）对应的类。MethodRequest类的子类
 - Result   表示执行结果的抽象类
 - FutureResult  在Future 模式中表示执行结果的类
 - RealResult  表示实际的执行结果的类
 - Servant      执行实际处理的类（实现了ActiveObject接口）

Main 类

import activeobject.ActiveObject;
import activeobject.ActiveObjectFactory;

public class Main {
  public static void main(String[] args) {
    ActiveObject activeObject = ActiveObjectFactory.createActiveObject();
    new MakerClientThread("Alice", activeObject).start();
    new MakerClientThread("Bobby", activeObject).start();
    new DisplayClientThread("Chris", acvtiveObject).start();  
  }
}

MakerClientThread 类

import  activeobject.ActiveObject;
import  activeobject.Result;

public class MakerClientThread extends Thread {
  private final ActiveObject activeObject;
  private final char fillchar;
  public MakerClientThread(String name, ActiveObject activeObject){
    super(name);
    this.activeObject = activeObject;
    this.fillchar = name.charAt(0);
  }
  public void run(){
    try {
      for(int i = 0; true; i++){
        Result result = activeObject.makeString(i, fillchar);
        Thread.sleep(10);
        String value = result.getResultValue();
        System.out.println(Thread.currentThread().getName() + ":  value = " + value);

      }
    } catch (InterruptedException e){}
  }
}

DisplayClientThread 类

import activeobject.ActiveObject;
import activeobject.Result;

public class DisplayClientThread extends Thread {
  private final ActiveObject activeObject;
  public DisplayClientThread(String name, ActiveObject activeObject){
    super(name);
    this.activeObject = activeObject;
  }
  public void run() {
    try {
      for( int i = 0; true; i++){
        String string = Thread.currentThread().getName() + "  " + i;
        activeObject.displayString(string);
        Thread.sleep(200);
      }
    } catch(InterruptedException e) {} 
  }
}

ActiveObject 接口

package activeobject;

public interface ActiveObject {
  public abstract Result makeString (int count, char fillchar);
  public abstract void displayString(String string);
}

ActiveObjectFactory 类

package activeobject;

public class ActiveObjectFactory {
  public static ActiveObject createActiveObject() {
    Servant servant = new Servant();
    ActivationQueue queue = new ActivationQueue();
    SchedulerThread scheduler = new SchedulerThread(queue);
    Proxy proxy = new Proxy(scheduler, servant);
    scheduler.start();
    return proxy;
  }
}

Proxy 类

package activeobject;

class Proxy implements ActiveObject {
  private final SchedulerThread scheduler;
  private final Servant servant;
  public Proxy(SchedulerThread scheduler, Servant servant) {
    this.scheduler = scheduler;
    this.servant = servant;
  }
  public  Result makeString(int count, char fillchar){
    FutureResult future = new FutureResult();
    scheduler.invoke(new MakeStringRequest

ScheduelrThread 类

package activeobject;

class SchedulerThread extends Thread {
  private final ActivationQueue  queue;
  private SchedulerThread(ActivationQueue queue){
    this.queue = queue;
  }
  public void invoke(MethodRequest request){
    queue.putRequest(request);
  }
  public void run(){
    while (true) {
      MethodRequest request = queue.takeRequest();
      request.execute();
    }
  }
}

ActivationQueue 类

package activeobject;

class ActivationQueue {
  private static final int MAX_METHOD_REQUEST  = 100;
  private final MethodRequest[]  requestQueue;
  private int tail;
  private int head;
  private int count;

  public ActivationQueue(){
    this.requestQueue = new MethodRequest[MAX_METHOD_REQUEST];
    this.head = 0;
    this.tail = 0;
    this.count = 0;
  }
  public synchronized void putRequest(MethodRequest request){
    while(count >= requestQueue.length){
       try{
        wait();
      } catch (InterruptedException e) {} 
     }

    requestQueue[tail] = request;
    tail = (tail + 1) % requestQueue.length;
    count++;
    notifyAll();
  }
  public synchronized MethodRequest takeRequest() {
    while (count <= 0 ){
        try{
          wait();
        } catch (InterruptedException e){}
     }
     MethodRequest request = requestQueue[head];
     head = (head + 1) % requestQueue.length;
     count--;
     notifyAll();
     return request;
  }
}

主动对象方 MethodRequest类`

package activeobject;

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():
}

主动对象方 MakeStringRequest 类

package activeobject;

class MakeStringRequest extends MethodRequest {
  private final int count;
  private final char fillchar;
  public MakeStringRequest(Servant servant, FutureResult future, int Count, char fillchar) {
    super(servant, future);
    this.count = count;
    this.fillchar = fillchar;
  }

  public void execute() {
    Result result = servant.makeString(Count, fillchar);
    future.setResult(result);
  }
}

主动对象方 DisplayStringRequest 类

package activeobject;

class DisplayStringRequest extends MethodRequest