8.什么是异步责任链？

并发编程(1)-java中的6中线程状态
并发编程(2)-怎么中断线程？
并发编程(3)-synchronized的实现原理
并发编程(4)-深入理解volatile关键字
并发编程(5)-ReentrantLock源码分析
并发编程(6)-Condition源码分析
并发编程(7)-juc阻塞队列介绍

一、普通责任链

@Data
public class Request {

    private String name;
}


@Data
public interface BaseHandler {
    void process(Request request);
}


@NoArgsConstructor
public class ValidaHandler implements BaseHandler{

    private BaseHandler nextHandler;

    private LinkedBlockingQueue blockingQueue = new LinkedBlockingQueue();

    public ValidaHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void process(Request request) {

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("ValidaHandler success..");
        if (nextHandler != null) {
            nextHandler.process(request);
        }
    }


}

@NoArgsConstructor
public class LoginHandler implements BaseHandler{

    private BaseHandler nextHandler;

    public LoginHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void process(Request request) {
        System.out.println("LoginHandler success..");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (nextHandler != null) {
            nextHandler.process(request);
        }
    }

}

@NoArgsConstructor
public class FinalHandler implements BaseHandler{

    private BaseHandler nextHandler;

    public FinalHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void process(Request request) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("FinalHandler success..");
        if (nextHandler != null) {
            nextHandler.process(request);
        }

    }
}


public class Test {

    public static void main(String[] args) {
        FinalHandler finalHandler = new FinalHandler();
        LoginHandler loginHandler = new LoginHandler(finalHandler);
        ValidaHandler validaHandler = new ValidaHandler(loginHandler);

        validaHandler.process(new Request());
    }


}

运行结果

如果责任链的链很长，会导入处理时间过久

二、异步责任链

@NoArgsConstructor
public class ValidaHandler extends Thread implements BaseHandler {

    private BaseHandler nextHandler;

    private LinkedBlockingQueue<Request> blockingQueue = new LinkedBlockingQueue();

    public ValidaHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void process(Request request) {
        blockingQueue.add(request);

    }


    @Override
    public void run() {

        try {

            Request request = blockingQueue.take();
            Thread.sleep(1000);
            if (request !=null && nextHandler != null) {
                nextHandler.process(request);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("ValidaHandler success..");
    }


}

@NoArgsConstructor
public class LoginHandler extends Thread implements BaseHandler {

    private BaseHandler nextHandler;

    private LinkedBlockingQueue<Request> blockingQueue = new LinkedBlockingQueue();

    public LoginHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void process(Request request) {

        blockingQueue.add(request);
    }


    @Override
    public void run() {

        try {
            Request request = blockingQueue.take();
            Thread.sleep(1000);
            if (request !=null &&nextHandler != null) {
                nextHandler.process(request);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("LoginHandler success..");

    }

}

@NoArgsConstructor
public class FinalHandler extends Thread implements BaseHandler {

    private BaseHandler nextHandler;

    private LinkedBlockingQueue<Request> blockingQueue = new LinkedBlockingQueue();

    public FinalHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void process(Request request) {
        blockingQueue.add(request);
    }


    @Override
    public void run() {

        try {
            Request request = blockingQueue.take();
            Thread.sleep(1000);
            if (request !=null && nextHandler != null) {
                nextHandler.process(request);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("FinalHandler success..");

    }
}

public class Test {

    public static void main(String[] args) {

        long currentTimeMillis = System.currentTimeMillis();
        FinalHandler finalHandler = new FinalHandler();
        finalHandler.start();
        LoginHandler loginHandler = new LoginHandler(finalHandler);
        loginHandler.start();
        ValidaHandler validaHandler = new ValidaHandler(loginHandler);
        validaHandler.start();
        validaHandler.process(new Request());
        // 运行时间
        System.out.println(System.currentTimeMillis() - currentTimeMillis);


    }


}

运行结果

可以快速响应结果，每个链异步执行