多线程程序设计学习(13)Active Object pattern-阿里云开发者社区

开发者社区> 无信不立> 正文

多线程程序设计学习(13)Active Object pattern

简介: Active Object[接收异步消息的对象]一:Active Object的参与者--->客户端线程(发起某种操作请求处理)--->代理角色(工头)--->实际执行者(工人)--->主动对象接口(工人和工头)--->生产端线程(加工产品的线程)--->存放生产请求的队列(存放请求的队列)--->...
+关注继续查看

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

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

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


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

 

 


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

一:订单和产品的接口

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 订单和产品的接口
 4  * @author sxf
 5  *
 6  */
 7 public abstract class Result {
 8     //获取结果的方法
 9     public abstract Object getResultValue();
10 
11 }
View Code

二:订单类

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 订单类
 4  * @author sxf
 5  *
 6  */
 7 public class FutureResult extends Result{
 8     //真正的产品
 9     private Result result;
10     //产品是否生产好
11     private boolean ready=false;
12     
13     //供生产线程使用,将生产好的产品放入订单
14     public synchronized void setResult(Result result){
15         this.result=result;
16         this.ready=true;
17         notifyAll();
18     }
19     
20     //从订单里获取真正的产品结果
21     @Override
22     public synchronized Object getResultValue() {
23         while(!ready){
24             try {
25                 wait();
26             } catch (InterruptedException e) {
27                 // TODO Auto-generated catch block
28                 e.printStackTrace();
29             }
30         }
31         return result.getResultValue();
32     }
33 
34     
35 }
View Code

三:产品类

 1 package com.yeepay.sxf.thread12;
 2 
 3 /**
 4  * 产品类
 5  * @author sxf
 6  *
 7  */
 8 public class RealResult extends Result {
 9     private final Object resultValue;
10     
11     //制造产品的方法
12     public RealResult(Object resultValue) {
13         // TODO Auto-generated constructor stub
14          this.resultValue=resultValue;
15      }
16 
17     //获得产品
18     @Override
19     public Object getResultValue() {
20         
21         return resultValue;
22     }
23     
24 
25 }
View Code

四:工头和工人的接口

 1 package com.yeepay.sxf.thread12;
 2 
 3 /**
 4  * 工头和工人的接口
 5  * @author sxf
 6  *
 7  */
 8 public interface ActiveObject {
 9     //制造字符串
10     public abstract Result makeString(int count,char fillchar);
11     
12     //显示字符串
13     public abstract void displayString(String string);
14 
15 }
View Code

五:工头类

 1 package com.yeepay.sxf.thread12;
 2 
 3 /**
 4  * 发起制作操作的代理(工头)
 5  * @author sxf
 6  *
 7  */
 8 public class Poxy implements ActiveObject{
 9     //制造操作的线程
10     private final SchedulerTHread schedulerTHread;
11     //制造操作的工人
12     private final Servant servant;
13     //构造器
14     public Poxy(SchedulerTHread schedulerTHread,Servant servant){
15         this.schedulerTHread=schedulerTHread;
16         this.servant=servant;
17     }
18     
19     /**
20      * 发起制造操作(开启制造操作的单据,并将制造原材料和制造工人打包,放入制造线程的队列中)
21      */
22     @Override
23     public Result makeString(int count, char fillchar) {
24         //制作一张订单
25         FutureResult future=new FutureResult();
26         //将原材料和工人和订单放入队列
27         schedulerTHread.Invoke(new MakeStringRequset(servant, future, count, fillchar));
28         //返回订单
29         return future;
30     }
31 
32     /**
33      * 查看字符串
34      */
35     @Override
36     public void displayString(String string) {
37         //这个制造不需要订单
38         schedulerTHread.Invoke(new DisplayStringRequest(servant, string));
39     }
40 
41     
42 }
View Code

六:工人类

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 执行者(工人)
 4  * @author sxf
 5  *
 6  */
 7 
 8 public class Servant implements ActiveObject {
 9 
10     /**
11      * 生产字符串
12      */
13     @Override
14     public Result makeString(int count, char fillchar) {
15         char[] buffer=new char[count];
16         for(int i=0;i<count;i++){
17             buffer[i]=fillchar;
18             try {
19                 Thread.sleep(100);
20             } catch (InterruptedException e) {
21                 // TODO Auto-generated catch block
22                 e.printStackTrace();
23             }
24         }
25         return new RealResult(buffer.toString());
26     }
27 
28     /**
29      * 打印字符串
30      */
31     @Override
32     public void displayString(String string) {
33         System.out.println("Servant.displayString()"+string);
34         try {
35             Thread.sleep(10);
36         } catch (InterruptedException e) {
37             // TODO Auto-generated catch block
38             e.printStackTrace();
39         }
40         
41     }
42 
43     
44 }
View Code

七:工作请求抽象的类

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 执行请求的实例(工人,订单,原材料)
 4  * @author sxf
 5  *
 6  */
 7 public  abstract class MethodRequest {
 8     //工人
 9     protected final Servant servant;
10     //订单
11     protected final FutureResult future;
12     
13     protected MethodRequest(Servant servant,FutureResult future) {
14         this.servant=servant;
15         this.future=future;
16     }
17     //工人的具体操作
18     public abstract void execute();
19 }
View Code

八:制造文字的请求

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 制造字符串请求实例
 4  * 其做用:将制造的发起者和制造的执行者分离。
 5  * ==》方法的启动和方法的执行进行分离
 6  * ==》分离的本质:(1)启动者将执行请求转换成实例(原材料,执行者,订单)
 7  *                               (2)执行者用原材料生产完产品,将产品存入订单,供发起者使用
 8  * @author sxf
 9  *
10  */
11 public class MakeStringRequset extends MethodRequest{
12     private final int count;
13     private final char fillchar;
14     //构造器(制造工人,订单,产品原材料)
15     public MakeStringRequset(Servant servant,FutureResult futureResult,int count,char fillchar) {
16         super(servant, futureResult);
17         this.count=count;
18         this.fillchar=fillchar;
19     }
20     
21     @Override
22     public void execute() {
23         //制造工人制造出产品
24         RealResult realResult=(RealResult) servant.makeString(count, fillchar);
25         //再将产品放入订单
26         future.setResult(realResult);
27     }
28 
29     
30 }
View Code

九:打印文字的请求

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 打印字符串的请求实例
 4  * @author sxf
 5  *
 6  */
 7 public class DisplayStringRequest extends MethodRequest{
 8     //打印原材料
 9     private final String string;
10     public DisplayStringRequest(Servant servant,String string){
11         super(servant, null);
12         this.string=string;
13     }
14     //执行打印的方法
15     @Override
16     public void execute() {
17         servant.displayString(string);
18     }
19     
20     
21 }
View Code

十:十:客户线程(1)(发起制造字符串请求的线程)

 1 package com.yeepay.sxf.thread12;
 2 
 3 /**
 4  * 发起制造字符串请求的线程
 5  * @author sxf
 6  *
 7  */
 8 public class MakerClientThread implements Runnable{
 9     //代理类(工头)
10     private final ActiveObject activeObject;
11     //生产原材料
12     private final char fillChar;
13     
14     public MakerClientThread(ActiveObject activeObject,char fillChar) {
15         this.activeObject=activeObject;
16         this.fillChar=fillChar;
17     }
18     
19     @Override
20     public void run() {
21         for(int i=0;true;i++){
22             //(工头)发起制造,得到订单
23             Result result=activeObject.makeString(i, fillChar);
24             //忙别的事情
25             try {
26                 Thread.sleep(1000);
27             } catch (InterruptedException e) {
28                 e.printStackTrace();
29             }
30             //从订单中获取产品结果
31             String value=(String) result.getResultValue();
32             //打印产品
33             System.out.println(Thread.currentThread().getName()+"=>value:["+value+"]");
34         }
35         
36     }
37     
38     
39 
40 }
View Code

十一:客户线程(2)发起打印字符串的请求线程

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 发起打印字符串请求的线程
 4  * @author sxf
 5  *
 6  */
 7 public class DisplayClientThread implements Runnable{
 8     //工头
 9     private final ActiveObject activeObject;
10     
11     public DisplayClientThread(ActiveObject activeObject){
12         this.activeObject=activeObject;
13     }
14 
15     @Override
16     public void run() {
17         for(int i=0;true;i++){
18             //打印原材料
19             String string=Thread.currentThread().getName()+"  "+i;
20             //工头进行找人打印
21             activeObject.displayString(string);
22             try {
23                 Thread.sleep(200);
24             } catch (InterruptedException e) {
25                 // TODO Auto-generated catch block
26                 e.printStackTrace();
27             }
28         }
29         
30     }
31     
32 }
View Code

十二:生产线程

 1 package com.yeepay.sxf.thread12;
 2 
 3 
 4 /**
 5  * 制造线程(制造原材料==>原材料+工人)
 6  * @author sxf
 7  *
 8  */
 9 public class SchedulerTHread implements Runnable{
10     //制造线程中的队列
11     private final ActivationQueue activatonQueue;
12     public SchedulerTHread(ActivationQueue  activationQueue) {
13         this.activatonQueue=activationQueue;
14     }
15     
16     //发起制造的线程,调用该方法,该方法是将制造请求(原材料+工人),放入队列
17     public void Invoke(MethodRequest request){
18         activatonQueue.putRequest(request);
19     }
20     
21     
22     //制造线程体
23     @Override
24     public void run() {
25         while(true){
26             //从队列中取出制造请求
27             MethodRequest request=activatonQueue.takeRequest();
28             //制造请求被执行
29             request.execute();
30         }
31         
32         
33     }
34 
35     
36 }
View Code

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

 1 package com.yeepay.sxf.thread12;
 2 
 3 /**
 4  * 队列
 5  * @author sxf
 6  *
 7  */
 8 public class ActivationQueue {
 9     private static final int MAX_METHOD_REQUEST=100;
10     private final MethodRequest[] requestQueue;
11     private int tail;//下一个put Request的地方
12     private int head;//下一个take Request的地方
13     private int countRequest;//request的数量
14     
15     public ActivationQueue() {
16         this.requestQueue=new MethodRequest[MAX_METHOD_REQUEST];
17         this.head=0;
18         this.tail=0;
19         this.countRequest=0;
20     }
21     
22     //放入请求
23     public synchronized void putRequest(MethodRequest request){
24         while(countRequest>=requestQueue.length){
25             try {
26                 wait();
27             } catch (InterruptedException e) {
28                 // TODO Auto-generated catch block
29                 e.printStackTrace();
30             }
31         }
32         requestQueue[tail]=request;
33         //计算下一个放请求的位置
34         tail=(tail+1)%requestQueue.length;
35         //请求数加1
36         countRequest++;
37         //唤醒其他线程
38          notifyAll();
39     }
40 
41     //取出请求
42     public synchronized MethodRequest takeRequest(){
43         while(countRequest<=0){
44             try {
45                 wait();
46             } catch (InterruptedException e) {
47                 // TODO Auto-generated catch block
48                 e.printStackTrace();
49             }
50         }
51         //取出
52         MethodRequest methodRequest=requestQueue[head];
53         //计算下一个取出请求的位置
54         head=(head+1)%requestQueue.length;
55         //请求数减去1
56         countRequest--;
57         //唤醒其他线程
58         notifyAll();
59         return methodRequest;
60     }
61 }
View Code

十四:产生工头的工厂类

 1 package com.yeepay.sxf.thread12;
 2 
 3 /**
 4  * 工头对象的工厂类
 5  * @author sxf
 6  *
 7  */
 8 public class ActiveObjectFactory {
 9     
10     //生产工头的对象
11     public static ActiveObject createActiveObject(){
12         //执行制造操作(工人)
13         Servant servant=new Servant();
14         //存放制造请求实例
15         ActivationQueue queue=new ActivationQueue();
16         //制造操作的线程
17         SchedulerTHread schedulerTHread=new SchedulerTHread(queue);
18         //发起制造动作(工头)
19         Poxy poxy=new Poxy(schedulerTHread, servant);
20         //启动制造操作的线程
21         new Thread(schedulerTHread).start();
22         return poxy;
23     }
24 }
View Code

十五:测试类

 1 package com.yeepay.sxf.thread12;
 2 /**
 3  * 测试类
 4  * @author sxf
 5  *
 6  */
 7 public class Test {
 8 
 9     public static void main(String[] args) {
10         ActiveObject activeObject=ActiveObjectFactory.createActiveObject();
11         new Thread(new  MakerClientThread(activeObject, 's')).start();;
12         new Thread(new DisplayClientThread(activeObject)).start();
13         
14     }
15 }
View Code

 

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
JAVA多线程高并发学习笔记(三)——Callable、Future和FutureTask
为什么要是用Callable和Future Runnable的局限性 Executor采用Runnable作为基本的表达形式,虽然Runnable的run方法能够写入日志,写入文件,写入数据库等操作,但是它不能返回一个值,或者抛出一个受检查的异常,有些需要返回值的需求就不能满足了。
1342 0
Java多线程高并发学习笔记——阻塞队列
在探讨可重入锁之后,接下来学习阻塞队列,这篇文章也是断断续续的写了很久,因为最近开始学ssm框架,准备做一个自己的小网站,后续可能更新自己写网站的技术分享。 请尊重作者劳动成果,转载请标明原文链接: http://www.cnblogs.com/superfj/p/7757876.html 阻塞队列是什么? 首先了解队列,队列是数据先进先出的一种数据结构。
951 0
Python爬虫之Xpath学习
问题解决 这是我昨天发的简书python爬虫之豆瓣音乐top250大牛们解决了一大部分的问题 1 MySQL报错问题 字段长度设置太小,说着也很奇怪,我用的vachar(20)都说小了,哎,后面建表干脆用text型,数据量不大还行。
790 0
《Windows 程序设计(第3版)》——第6章 框架中的窗口 6.1 CWnd类的引出
在类的体系结构中,框架程序提供了CWnd类来封装窗口的HWND句柄,即使用CWnd类来管理窗口的对象,这包括窗口的创建和销毁、窗口的一般行为和窗口所接受的消息。
1039 0
设计模式-学习之路
设计模式-学习之路 设计模式六大原则 单一职责原则 里氏代换原则 依赖倒置原则 接口隔离原则 迪米特法则 开闭原则 23种设计模式 创建型模式 工厂方法模式 抽象工厂模式 单例模式 建造者模式 原型模式 结构性模式 适配...
848 0
Android学习之path类
import android.app.Activity; import android.content.Context; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.ComposePathEffect; import android.graphics.Corne
941 0
+关注
无信不立
人无信不立,业不勤不精
595
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载