Disruptor 实践：整合到现有的爬虫框架

一. Disruptor

Disruptor 是一个高性能的异步处理框架。

Disruptor 是 LMAX 在线交易平台的关键组成部分，LMAX平台使用该框架对订单处理速度能达到600万TPS，除金融领域之外，其他一般的应用中都可以用到Disruptor，它可以带来显著的性能提升。其实 Disruptor 与其说是一个框架，不如说是一种设计思路，这个设计思路对于存在“并发、缓冲区、生产者—消费者模型、事务处理”这些元素的程序来说，Disruptor提出了一种大幅提升性能（TPS）的方案。

二. 实践

NetDiscovery 是基于 Vert.x、RxJava 2 等框架实现的爬虫框架。

NetDiscovery 默认的消息队列采用 JDK 的 ConcurrentLinkedQueue，由于爬虫框架各个组件都可以被替换，所以下面基于 Disruptor 实现爬虫的 Queue。

2.1 事件的封装

将爬虫的 request 封装成一个 RequestEvent，该事件会在 Disruptor 中传输。

1. import com.cv4j.netdiscovery.core.domain.Request;

2. import lombok.Data;

4. /**

5. * Created by tony on 2018/9/1.

6. */

7. @Data

8. public class RequestEvent {

10.    private Request request;

12.    public String toString() {

14.        return request.toString();

15.    }

16. }

2.2 发布事件

下面编写事件的发布，从 RingBuffer 中获取下一个可写入事件的序号，将爬虫要请求的 request 设置到 RequestEvent 事件中，最后将事件提交到 RingBuffer。

1. import com.cv4j.netdiscovery.core.domain.Request;

2. import com.lmax.disruptor.RingBuffer;

4. import java.util.concurrent.atomic.AtomicInteger;

6. /**

7. * Created by tony on 2018/9/2.

8. */

9. public class Producer {

11.    private final RingBuffer<RequestEvent> ringBuffer;

13.    private AtomicInteger count = new AtomicInteger(0); // 计数器

15.    public Producer(RingBuffer<RequestEvent> ringBuffer) {

16.        this.ringBuffer = ringBuffer;

17.    }

19.    public void pushData(Request request){

20.        long sequence = ringBuffer.next();

22.        try{

23.            RequestEvent event = ringBuffer.get(sequence);

24.            event.setRequest(request);

25.        }finally {

26.            ringBuffer.publish(sequence);

27.            count.incrementAndGet();

28.        }

29.    }

31.    /**

32.     * 发送到队列中到Request的数量

33.     * @return

34.     */

35.    public int getCount() {

37.        return count.get();

38.    }

39. }

2.3 消费事件

RequestEvent 设置了 request 之后，消费者需要处理具体的事件。下面的 Consumer 仅仅是记录消费者的线程名称以及 request。真正的“消费”还是需要从 DisruptorQueue 的 poll() 中获取 request ，然后在 Spider 中进行“消费”。

1. import com.lmax.disruptor.WorkHandler;

2. import lombok.extern.slf4j.Slf4j;

4. import java.util.concurrent.atomic.AtomicInteger;

6. /**

7. * Created by tony on 2018/9/2.

8. */

9. @Slf4j

10. public class Consumer implements WorkHandler<RequestEvent> {

12.    @Override

13.    public void onEvent(RequestEvent requestEvent) throws Exception {

15.        log.info("consumer:" + Thread.currentThread().getName() + " requestEvent: value=" + requestEvent.toString());

16.    }

17. }

2.4 DisruptorQueue 的实现

Disruptor 支持单生产者单消费者、多生产者、多消费者、分组等方式。

在 NetDiscovery 中采用多生产者多消费者。

在 RingBuffer 创建时，ProducerType 使用 MULTI 类型表示多生产者。创建 RingBuffer 采用了 YieldingWaitStrategy 。YieldingWaitStrategy 是一种WaitStrategy，不同的 WaitStrategy 会有不同的性能。

YieldingWaitStrategy 性能是最好的，适合用于低延迟的系统。在要求极高性能且事件处理线数小于CPU逻辑核心数的场景中，推荐使用此策略；例如，CPU开启超线程的特性。

1.        ringBuffer = RingBuffer.create(ProducerType.MULTI,

2.                new EventFactory<RequestEvent>() {

3.                    @Override

4.                    public RequestEvent newInstance() {

5.                        return new RequestEvent();

6.                    }

7.                },

8.                ringBufferSize ,

9.                new YieldingWaitStrategy());

EventProcessor 用于处理 Disruptor 中的事件。

EventProcessor 的实现类包括：BatchEventProcessor 用于单线程批量处理事件，WorkProcessor 用于多线程处理事件。

WorkerPool 管理着一组 WorkProcessor。创建完 ringBuffer 之后，创建 workerPool：

1.        SequenceBarrier barriers = ringBuffer.newBarrier();

3.        for (int i = 0; i < consumers.length; i++) {

4.            consumers[i] = new Consumer();

5.        }

7.        workerPool = new WorkerPool<RequestEvent>(ringBuffer,

8.                        barriers,

9.                        new EventExceptionHandler(),

10.                        consumers);

启动 workerPool：

1.        ringBuffer.addGatingSequences(workerPool.getWorkerSequences());

2.        workerPool.start(Executors.newFixedThreadPool(threadNum));

最后是 DisruptorQueue 完整的代码：

1. import com.cv4j.netdiscovery.core.domain.Request;

2. import com.cv4j.netdiscovery.core.queue.AbstractQueue;

3. import com.lmax.disruptor.*;

4. import com.lmax.disruptor.dsl.ProducerType;

5. import lombok.extern.slf4j.Slf4j;

7. import java.util.concurrent.Executors;

8. import java.util.concurrent.atomic.AtomicInteger;

10. /**

11. * Created by tony on 2018/9/1.

12. */

13. @Slf4j

14. public class DisruptorQueue extends AbstractQueue {

16.    private RingBuffer<RequestEvent> ringBuffer;

18.    private Consumer[] consumers = null;

19.    private Producer producer = null;

20.    private WorkerPool<RequestEvent> workerPool = null;

21.    private int ringBufferSize = 1024*1024; // RingBuffer 大小，必须是 2 的 N 次方

23.    private AtomicInteger consumerCount = new AtomicInteger(0);

25.    private static final int CONSUME_NUM = 2;

26.    private static final int THREAD_NUM = 4;

28.    public DisruptorQueue() {

30.        this(CONSUME_NUM,THREAD_NUM);

31.    }

33.    public DisruptorQueue(int consumerNum,int threadNum) {

35.        consumers = new Consumer[consumerNum];

37.        //创建ringBuffer

38.        ringBuffer = RingBuffer.create(ProducerType.MULTI,

39.                new EventFactory<RequestEvent>() {

40.                    @Override

41.                    public RequestEvent newInstance() {

42.                        return new RequestEvent();

43.                    }

44.                },

45.                ringBufferSize ,

46.                new YieldingWaitStrategy());

48.        SequenceBarrier barriers = ringBuffer.newBarrier();

50.        for (int i = 0; i < consumers.length; i++) {

51.            consumers[i] = new Consumer();

52.        }

54.        workerPool = new WorkerPool<RequestEvent>(ringBuffer,

55.                        barriers,

56.                        new EventExceptionHandler(),

57.                        consumers);

59.        ringBuffer.addGatingSequences(workerPool.getWorkerSequences());

60.        workerPool.start(Executors.newFixedThreadPool(threadNum));

62.        producer = new Producer(ringBuffer);

63.    }

65.    @Override

66.    protected void pushWhenNoDuplicate(Request request) {

68.        producer.pushData(request);

69.        try {

70.            Thread.sleep(100);

71.        } catch (InterruptedException e) {

72.            e.printStackTrace();

73.        }

74.    }

76.    @Override

77.    public Request poll(String spiderName) {

79.        Request request = ringBuffer.get(ringBuffer.getCursor() - producer.getCount() +1).getRequest();

80.        ringBuffer.next();

81.        consumerCount.incrementAndGet();

82.        return request;

83.    }

85.    @Override

86.    public int getLeftRequests(String spiderName) {

88.        return producer.getCount()-consumerCount.get();

89.    }

91.    public int getTotalRequests(String spiderName) {

93.        return super.getTotalRequests(spiderName);

94.    }

96.    static class EventExceptionHandler implements ExceptionHandler {

98.        public void handleEventException(Throwable ex, long sequence, Object event) {

100.            log.debug("handleEventException：" + ex);

101.        }

103.        public void handleOnStartException(Throwable ex) {

105.            log.debug("handleOnStartException：" + ex);

106.        }

108.        public void handleOnShutdownException(Throwable ex) {

110.            log.debug("handleOnShutdownException：" + ex);

111.        }

112.    }

113. }

其中，pushWhenNoDuplicate() 是将 request 发送到 ringBuffer 中。poll() 是从 ringBuffer 中取出对应的 request ，用于爬虫进行网络请求、解析请求等处理。

总结：

爬虫框架 github 地址：https://github.com/fengzhizi715/NetDiscovery

上述代码是比较经典的 Disruptor 多生产者多消费者的代码，亦可作为样板代码使用。

最后，在爬虫框架是面向接口编程的，所以替换其中的任意组件都比较方便。

该系列的相关文章：

从API到DSL —— 使用 Kotlin 特性为爬虫框架进一步封装

使用Kotlin Coroutines简单改造原有的爬虫框架

为爬虫框架构建Selenium模块、DSL模块(Kotlin实现)

基于Vert.x和RxJava 2构建通用的爬虫框架

关注【Java与Android技术栈】

更多精彩内容请关注扫码：