Java多线程程异步改造责任链模式，大幅提高吞吐量
- 一、责任链模式是什么
- 二、责任链模式的优缺点
- 三、责任链模式示例
- （一）、责任链模板
- （二）、消费者
- （三）、一级优惠处理
- （四）、二级优惠处理
- （五）、APP应用场景
- （六）、运行结果
- 四、改造责任链，增加吞吐量
- （一）、责任链模板
- （二）、优雅停止线程
- （三）、APP应用场景
- （四）、运行结果
- 五、总结反思
对基础设计模式了然于胸的可以直接跳过前面章节，查看优化部分
一、责任链模式是什么
责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，请求会自动进行传递。所以责任链将请求的发送者和请求的处理者解耦了。
二、责任链模式的优缺点
责任链模式是一种对象行为型模式，其主要优点如下。
- 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
- 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
- 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
- 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
- 责任分担,每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。
其主要缺点如下。
- 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
- 对比较长的职责链，请求的处理可能涉及多个处理对象，会增加过多对象，而且会因为要等待链条处理完毕，会影响系统性能。
- 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。
三、责任链模式示例
例如：客户去消费，根据会员卡等级不同有不同的优惠政策，LV.3客户可以累计享受1-3等客户的优惠。
本文还结合使用了模板方法，可参考模板方法模式（常用设计模式之一）
定义一个操作中算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。通俗点的理解就是 ：完成一件事情，有固定的数个步骤，但是每个步骤根据对象的不同，而实现细节不同；就可以在父类中定义一个完成该事情的总方法，按照完成事件需要的步骤去调用其每个步骤的实现方法。每个步骤的具体实现，由子类完成。
（一）、责任链模板
/**
* 责任链模板
*/
public abstract class Handler {
/**
* 当前优惠政策等级
*/
public final int rank;
public Handler(int rank) {
this.rank = rank;
}
private Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public Handler getNextHandler() {
return nextHandler;
}
/**
* 用了模板方法设计模式（非常经典的一种设计模式，优雅），即预设一定流程，留下钩子函数，用户自定义实现
*
* @param customer 待处理客户
*/
public void handle(Customer customer) {
if (customer.getRank() >= rank) {
handleHook(customer);
}
if (nextHandler != null) {
nextHandler.handle(customer);
}else {
System.out.println("==================计算优惠结束======================");
}
}
/**
* 优惠政策具体实现
*
* @param customer 待处理客户
*/
protected abstract void handleHook(Customer customer);
}（二）、消费者
/*
* 消费者
*/
public class Customer {
/**
* 消费等级
*/
private int rank;
/**
* 姓名
*/
private String name;
/**
* 消费额
*/
private double consumption;
public Customer(int rank, String name, double consumption) {
this.rank = rank;
this.name = name;
this.consumption = consumption;
}
public int getRank() {
return rank;
}
public double getConsumption() {
return consumption;
}
public void setConsumption(double consumption) {
this.consumption = consumption;
}
public void setRank(int rank) {
this.rank = rank;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}（三）、一级优惠处理
/**
* LV.1客户优惠处理
*/
public class FirstHandler extends Handler {
/**
* 当前优惠政策为LV.1客户
*/
public FirstHandler() {
super(1);
//也可省去此处代码，在应用场景中自由组合
setNextHandler(new TwiceHandler());
}
@Override
protected void handleHook(Customer customer) {
//模拟复杂逻辑处理
System.out.println("==================开始计算优惠======================");
customer.setConsumption(customer.getConsumption() * 0.7);
System.out.println("你是LV." + customer.getRank() + "等客户"
+customer.getName()+"，当前可享受7折"+"折扣后价格是"+customer.getConsumption());
}
}（四）、二级优惠处理
/**
* LV.2客户优惠处理
*/
public class TwiceHandler extends Handler {
/**
* 当前优惠政策为LV.2客户
*/
public TwiceHandler() {
super(2);
}
@Override
protected void handleHook(Customer customer) {
//模拟复杂逻辑处理
double consumption = customer.getConsumption() - Math.floor(customer.getConsumption() / 100) * 7;
System.out.println("你是LV." + customer.getRank() +
"等客户"+customer.getName()+"，可在7折优惠后满100-7元,折扣后价格是"+consumption);
}
}（五）、APP应用场景
public class App {
public static void main(String[] args) {
Customer bob = new Customer(2, "bob", 1000);
Customer tom = new Customer(1, "tom", 1000);
new FirstHandler().handle(bob);
new FirstHandler().handle(tom);
}
}（六）、运行结果
四、改造责任链，增加吞吐量
只需修改模板即可，变化被封装到了一个类中，复杂的算法过程可以使用该设计模式（类库设计者进行开发），开发人员只需继承该类，简单的实现钩子函数即可完成复杂的流程。例如java并发包中的AQS就是这样设计的，开发人员可以简单的通过实现个别方法而完成自定义锁。
（一）、责任链模板
/**
* 责任链模板
*/
public abstract class Handler extends Thread {
/**
* 当前优惠政策等级
*/
private final int rank;
/**
* 有界阻塞队列（Integer.max为界）
*/
LinkedBlockingQueue<Customer> customers = new LinkedBlockingQueue<>();
public Handler(int rank) {
this.rank = rank;
this.start();
}
private Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public Handler getNextHandler() {
return nextHandler;
}
/**
* 用了模板方法设计模式，即预设一定流程，留下钩子函数，用户自定义实现,模板模式是精华
*/
@Override
public void run() {
while (true) {
try {
//阻塞方法，直到取到
Customer customer = customers.take();
if (customer.getRank() >= rank) {
handleHook(customer);
}
if (nextHandler != null) {
nextHandler.addCustomer(customer);
}
} catch (InterruptedException e) {
return;
}
}
}
/**
* 使用该方法将请求添加到阻塞队列中，使得该环节在添加完成之后快速返回，不需要等待链条逐层执行完毕之后返回
*
* @param customer 待处理客户
*/
public void addCustomer(Customer customer) {
//阻塞方法，直到加入
customers.offer(customer);
}
/**
* 优惠政策具体实现
*
* @param customer 待处理客户
*/
protected abstract void handleHook(Customer customer);
}（二）、优雅停止线程
停止线程的方式之一，thread.stop()方法不推荐使用，因为它完全不可控。
/**
* 停止责任链，不能使用用Handler线程本身停止自己，这会抛出异常
*/
public class StopUtil {
public static void stop(Handler handler) {
handler.interrupt();
if (handler.getNextHandler() != null) {
stop(handler);
}
}
}（三）、APP应用场景
public class App {
public static void main(String[] args) throws InterruptedException {
Customer bob = new Customer(2, "bob", 1000);
Customer tom = new Customer(2, "tom", 1000);
FirstHandler handler = new FirstHandler();
handler.addCustomer(bob);
handler.addCustomer(tom);
Thread.sleep(5000);
StopUtil.stop(handler);
System.out.println("优雅停止线程的方法之一：使用中断");
}
}（四）、运行结果
可以发现，同一客户仍延续责任链顺序执行，对于两个不同客户而言，两个处理节点之间不是顺序的，即每个节点异步处理，增加了责任链的吞吐量。也就是说本来完整的流程是 节点一 => 节点二 => 返回结果 转换为 添加到节点一 => 返回,而真正的处理是异步线程去获取待处理元素，take()阻塞取到后进行处理，传递给下一节点立即返回，接着处理第二个请求，而不用等待第二节点处理完毕再返回结果。
类似消息队列的处理方式，处理请求时可快速返回，增加吞吐量。
五、总结反思
- 是否可以使用
volatile变量代替while(true)来停止线程,该方法可以让线程停下来吗?（提示：有可能停也有可能不停）即：
volatile boolean stop = false;
public void run() {
while (!stop) {
try {
//阻塞方法，直到取到
Customer customer = customers.take();
if (customer.getRank() >= rank) {
handleHook(customer);
}
if (nextHandler != null) {
nextHandler.addCustomer(customer);
}
} catch (InterruptedException e) {
return;
}
}
public void stopHandle(){
stop = true;
}-
interrupt()方法在这里使用为什么说它是优雅的？它一定会让线程立即停止吗？（提示：interrupt()方法为什么会让线程停止呢？）
欢迎各位大佬在评论区写出你的答案。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
