首先，这是责任链的专门实现。不要以为所有责任链都这样做，因为它们没有。

也就是说，如果要在第一个任务仍在运行时运行第二个任务，则需要确保的主要事情是不要阻塞调用方（“主”）线程。我想慢元素需要将工作转移到其他线程上，并有一个标志来表示它正在忙于做某事。

这是一个快速的代码草图

interface Link {
    void handle(int i);
}

class SlowLink implements Link {
    private final AtomicBoolean isBusy = new AtomicBoolean(false);
    private final Link next;

    SlowLink(Link next) { this.next = next; }

    @Override
    public void handle(int i) {
        if (isBusy.compareAndSet(false,true)) {
            new Thread(() -> handleAsync(i)).start();
        }
        else {
            next.handle(i);
        }
    }

    private void handleAsync(int i) {
        try {
            Thread.sleep(3000);
            System.out.println("slow " + i);
            isBusy.set(false);
        }
        catch (InterruptedException e) {}
    }
}

class QuickLink implements Link {
    @Override
    public void handle(int i) {
        System.out.println("quick " + i);
    }
}

class Scratch {
    public static void main(String[] args) throws InterruptedException {
        Link chain = new SlowLink(new QuickLink());
        chain.handle(5);
        Thread.sleep(1000);
        chain.handle(2);
    }
}

正如迈克尔提到的，您的是COR（责任链）的特殊实现。

如果您的需求只是一个异步多线程代码，那么COR不是要使用的候选模式。而是使用Customized Singleton，它具有从“ n”个实例池中提供下一个可用实例的功能。

如果您需要处理多种类型的请求，并且某些类型的请求以异步方式处理，那么使用COR会有所帮助。

如果我们看到COR模式的结构，则它包含由方法 handleRequest（）的 Handler 类型的链接形成的链。每个具体的处理程序都通过实现handleRequest（）来专门处理一种类型的请求

if (canHandle){
    handleIt();
} else if (hasNextHandler()){
    passItToNextHandler();
} else {
    // complete chain is unable to handle it. So leave it may be log it
}

现在，由于链中有两个（或更多）同一个Concrete类型的处理程序实例，这看起来像是违反规则的hack（尽管它可以工作）。

我宁愿建议通过在链中链接每种类型的具体处理程序的单个实例来保持COR整洁。需要异步处理多个实例的处理程序，将此多线程任务委托给来自handleRequest（）的对象池。可以作为处理“ n”个实例而不是单个实例的定制Singleton。

这将分离两个关注点，即COR和对象池。两者都可以独立维护，无需任何Hack。