Disruptor 高性能并发框架二次封装

Disruptor是一款java高性能无锁并发处理框架。和JDK中的BlockingQueue有相似处，但是它的处理速度非常快！！！号称“一个线程一秒钟可以处理600W个订单”（反正渣渣电脑是没体会到）。

Disruptor功能十分强大，比如消费者阻塞等待；生产者-消费者一对一、一对多、多对一、多对多；构建消费者串/并行处理链等等。

具体的概念模型可以参考：https://www.cnblogs.com/haiq/p/4112689.html

下面是我基于Disruptor框架封装的工具。采用fluent编码风格，简化了Disruptor的调用。

package com.gravel.demo.test.disruptor;

import com.gravel.demo.test.disruptor.base.EventProducer;
import com.gravel.demo.test.disruptor.base.Publisher;
import com.gravel.demo.test.disruptor.base.PublisherBuilder;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description: Disruptor 高性能异步处理框架
 */
public class DisruptorTest {

    public static void main(String[] args) throws Exception {
        builderTest();
    }

    private static void builderTest() throws Exception {
        // 创建多个生产者实例
        EventProducer<Domain> producer1 = new EventProducer<>("producer1");
        EventProducer<Domain> producer2 = new EventProducer<>("producer2");

        // 创建多个消费者实例
        DomainConsumer handler1 = new DomainConsumer("handler1");
        DomainConsumer handler2 = new DomainConsumer("handler2");
        DomainConsumer after1 = new DomainConsumer("after1");
        DomainConsumer after2 = new DomainConsumer("after2");
        DomainConsumer after3 = new DomainConsumer("after3");
        DomainConsumer then = new DomainConsumer("then");

        // 创建消息发布者
        final Publisher<Domain> publisher = PublisherBuilder.newBuilder()
                // 设置线程工厂
                // .threadFactory(r -> new Thread(r))
                // .threadFactory(new LimitedThreadFactory())
                // .threadFactory(Executors.defaultThreadFactory())
                // 设置生产类型
                // .producerType(ProducerType.SINGLE)
                // .producerType(ProducerType.MULTI)
                // 设置事件工厂
                // .eventFactory(new EventFactory())
                // 设置等待策略
                // .waitStrategy(new SleepingWaitStrategy())
                // .waitStrategy(new YieldingWaitStrategy())
                // 设置发布方式
                // .publishStrategy(PublishStrategy.TRANSLATOR)
                // .publishStrategy(PublishStrategy.NORMAL)
                // 设置ringBuffer大小
                // .ringSize(1024 * 8)
                // 设置异常处理器
                .exceptionHandler(new DomainErrorHandler<>())
                // 初始化Disruptor, 在配置生产者和消费者之前一定要先初始化。
                .disruptor()
                // 设置单生产者
                // .producer(producer1)
                // 配置单个消费者
                // .handler(handler1)
                // 配置多生产者
                .producer(producer1, producer2)
                //  ======  设置多个workers或者handlers处理链 start  =======
                // .worker(handler1)
                .handler(handler1, handler2)
                .after(handler1).handler(after1)
                .after(handler2).handler(after2)
                .after(after1, after2).handler(after3)
                // .then(after3)
                //  ======  设置多个workers或者handlers处理链 end  =======
                // 启动
                .build();

        long start = System.currentTimeMillis();
        try {

            for (int i = 0; i < 500; i++) {
                publisher
                        // 可连续发布
                        //.publish(new Domain(String.valueOf("a" + i), "init"))
                        .publish(new Domain(String.valueOf(i), "init"));
            }
        } finally {
            long sleep = 200;
            Thread.sleep(sleep);
            System.out.println("used time: " + (System.currentTimeMillis() - start - sleep) + "ms");

            publisher.shutdown();
        }
    }
}

　　

从上面的代码来看，我们封装的工具类入口是Publisher。他可以配置一系列Disruptor需要的参数，如线程工厂（ThreadFactory）、事件工厂（EventFactory）、等待策略（WaitStrategy）、消息生产者（Producer）、消费者（Handler/Worker）等等。

其中消息生产者和消费者是Publisher的关键，所以稍后重点描述。先看看其他PublisherBuilder类。

package com.gravel.demo.test.disruptor.base;

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

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public class PublisherBuilder {
    // Publish 默认参数
    private static final int RING_SIZE = 1024 * 8;
    private static final ThreadFactory THREAD_FACTORY = Executors.defaultThreadFactory();
    private static final WaitStrategy WAIT_STRATEGY = new SleepingWaitStrategy();
    private static final com.lmax.disruptor.EventFactory EVENT_FACTORY = new EventFactory();
    private static final ProducerType PRODUCER_TYPE = ProducerType.SINGLE;
    private static final PublishStrategy PUBLISH_STRATEGY = PublishStrategy.TRANSLATOR;

    private com.lmax.disruptor.EventFactory eventFactory;
    private ThreadFactory threadFactory;
    private WaitStrategy waitStrategy;
    private ExceptionHandler exceptionHandler;
    private ProducerType type;
    private PublishStrategy publishStrategy;
    private EventPublisher publisher;
    private int ringSize;

    public static PublisherBuilder newBuilder() {
        return new PublisherBuilder();
    }

    /**
     * 指定ringBuffer size,最好为2的n次方。默认1024*8
     *
     * @param ringSize
     * @return
     */
    public PublisherBuilder ringSize(int ringSize) {
        this.ringSize = ringSize;
        return this;
    }

    /**
     * 指定eventFactory， 默认EventFactory
     *
     * @param eventFactory
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder eventFactory(com.lmax.disruptor.EventFactory eventFactory) {
        this.eventFactory = eventFactory;
        return this;
    }

    /**
     * 指定ThreadFactory, 默认Executors.defaultThreadFactory()
     *
     * @param threadFactory
     * @return
     */
    public PublisherBuilder threadFactory(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        return this;
    }

    /**
     * 指定等待策略, 默认SleepingWaitStrategy
     *
     * @param waitStrategy
     * @return
     */
    public PublisherBuilder waitStrategy(WaitStrategy waitStrategy) {
        this.waitStrategy = waitStrategy;
        return this;
    }

    public PublisherBuilder publishStrategy(PublishStrategy publishStrategy) {
        this.publishStrategy = publishStrategy;
        return this;
    }

    /**
     * 初始化disruptor
     *
     * @return
     */
    public PublisherBuilder disruptor() {
        this.eventFactory = this.eventFactory == null ? EVENT_FACTORY : this.eventFactory;
        this.threadFactory = this.threadFactory == null ? THREAD_FACTORY : this.threadFactory;
        this.waitStrategy = this.waitStrategy == null ? WAIT_STRATEGY : this.waitStrategy;
        this.ringSize = this.ringSize <= 0 ? RING_SIZE : this.ringSize;
        this.type = this.type == null ? PRODUCER_TYPE : this.type;
        this.publishStrategy = this.publishStrategy == null ? PUBLISH_STRATEGY : this.publishStrategy;

        publisher = new EventPublisher<>(eventFactory, ringSize, threadFactory, waitStrategy, exceptionHandler, type, publishStrategy);
        return this;
    }

    /**
     * 配置生产者
     * @param producers
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder producer(EventProducer<T> ...producers) {
        if (isInit()) {
            this.publisher.producer(producers);
        }
        return this;
    }

    /**
     * eventHandler：每个event事件可以被所有handler处理
     *
     * @param eventHandlers
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder handler(EventHandler<Event<T>>... eventHandlers) {
        if (isInit()) {
            this.publisher.eventHandler(eventHandlers);
        }
        return this;
    }

    /**
     * workHandler：每个event事件只能被一个work处理
     *
     * @param workHandlers
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder worker(WorkHandler<Event<T>>... workHandlers) {
        if (isInit()) {
            this.publisher.workHandler(workHandlers);
        }
        return this;
    }

    /**
     * handler或work之后处理
     *
     * @param thenEventHandlers
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder then(EventHandler<Event<T>>... thenEventHandlers) {
        if (isInit()) {
            this.publisher.thenHandler(thenEventHandlers);
        }
        return this;
    }

    /**
     * 顺序指定handler，不可接直接在worker方法后面调用
     *
     * @param afterEventHandlers
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder after(EventHandler<Event<T>>... afterEventHandlers) {
        if (isInit()) {
            this.publisher.afterHandler(afterEventHandlers);
        }
        return this;
    }

    /**
     * 指定producerType
     *
     * @param type
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder producerType(ProducerType type) {
        this.type = type;
        return this;
    }

    /**
     * 异常处理类
     *
     * @param exceptionHandler
     * @param <T>
     * @return
     */
    public <T> PublisherBuilder exceptionHandler(ExceptionHandler<T> exceptionHandler) {
        this.exceptionHandler = exceptionHandler;
        return this;
    }

    private boolean isInit() {
        if (this.publisher == null) {
            throw new IllegalStateException("execute disruptor() function before set handlers or workers.");
        }
        return true;
    }

    public <T> Publisher<T> build() {
        return this.publisher.start();
    }
}

　　

其中关键代码是disruptor()方法，即Disruptor实例化入口。因为eventHandler和workHandler的指定必须在disruptor实例之后，disruptor.start()启动之前。

所以我们调用工具类必须如下：

PublisherBuilder.newBuilder()/*.各种配置*/.disruptor()/*指定producer和handler/worker*/.build();

　　

来看看PublisherBuilder中的EventPulisher类， 他实现了Publisher接口， 如下：

Publisher.java

package com.gravel.demo.test.disruptor.base;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public interface Publisher<T> {

    Publisher<T> start();

    Publisher<T> publish(T t);

    Publisher<T> shutdown();
}

　　

EventPublisher.java

package com.gravel.demo.test.disruptor.base;

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.EventHandlerGroup;
import com.lmax.disruptor.dsl.ProducerType;

import java.util.Objects;
import java.util.concurrent.ThreadFactory;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public class EventPublisher<T> implements Publisher<T> {

    private RingBuffer<Event<T>> ringBuffer;
    private Disruptor<Event<T>> disruptor;
    private EventHandlerGroup<Event<T>> handlerGroup;
    private PublisherState state;
    private PublishStrategy publishStrategy;
    private EventTranslator<T> translator;
    private Producer<T>[] producers;

    private enum PublisherState {
        START, SHUTDOWN
    }

    public EventPublisher(com.lmax.disruptor.EventFactory<Event<T>> factory,
                          int ringSize,
                          ThreadFactory threadFactory,
                          WaitStrategy waitStrategy,
                          ExceptionHandler<Event<T>> exceptionHandler,
                          ProducerType type,
                          PublishStrategy publishStrategy) {

        this.disruptor = new Disruptor<>(factory, ringSize, threadFactory,
                type, waitStrategy);

        if (!Objects.isNull(exceptionHandler)) {
            this.disruptor.setDefaultExceptionHandler(exceptionHandler);
        }

        this.ringBuffer = disruptor.getRingBuffer();

        this.publishStrategy = publishStrategy;
        if (publishStrategy == PublishStrategy.TRANSLATOR) {
            translator = new EventTranslator<>();
        }

        this.state = PublisherState.SHUTDOWN;
    }

    public EventPublisher<T> producer(EventProducer<T> ...producers) {
        if (!Objects.isNull(producers) && producers.length > 0) {
            for (EventProducer<T> producer : producers) {
                producer.setRingBuffer(this.ringBuffer).setTranslator(this.translator);
            }
            this.producers = producers;
        }
        return this;
    }

    public EventPublisher<T> eventHandler(EventHandler<Event<T>>... eventHandlers) {
        if (this.handlerGroup != null) {
            this.handlerGroup.handleEventsWith(eventHandlers);
        } else {
            this.handlerGroup = disruptor.handleEventsWith(eventHandlers);
        }
        return this;
    }

    public EventPublisher<T> workHandler(WorkHandler<Event<T>>... workHandlers) {
        if (this.handlerGroup != null) {
            this.handlerGroup.handleEventsWithWorkerPool(workHandlers);
        } else {
            this.handlerGroup = disruptor.handleEventsWithWorkerPool(workHandlers);
        }
        return this;
    }

    public EventPublisher<T> thenHandler(EventHandler<Event<T>>... thenHandlers) {
        this.handlerGroup.then(thenHandlers);
        return this;
    }

    public EventPublisher<T> afterHandler(EventHandler<Event<T>>... afterHandlers) {
        this.handlerGroup = this.disruptor.after(afterHandlers);
        return this;
    }

    public Disruptor<Event<T>> getDisruptor() {
        return disruptor;
    }

    @Override
    public EventPublisher<T> start() {
        this.disruptor.start();
        this.state = PublisherState.START;
        return this;
    }

    @Override
    public EventPublisher<T> shutdown() {
        this.disruptor.shutdown();
        this.state = PublisherState.SHUTDOWN;
        return this;
    }

    @Override
    public EventPublisher<T> publish(T t) {
        if (!isStarted()) {
            throw new IllegalStateException("publisher not start..");
        }
        if (producers == null || producers.length <= 0) {
            throw new IllegalStateException("producer must be specify.");
        }

        for (Producer<T> producer : producers) {
            producer.produce(t);
        }
        return this;
    }

    private boolean isStarted() {
        return this.state == PublisherState.START;
    }
}

　　

其中，比较重要的代码是指定生产者及消费者链(！！！贼好用！！！)。动态参数表示生产者和消费者可以是一对一、一对多、多对一、多对多的关系。

先来讲讲publisher的最小数据单位Event

package com.gravel.demo.test.disruptor.base;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public class Event<T> {

    private T data;

    public void set(T data) {
        this.data = data;
    }

    public T get() {
        return data;
    }
}

　　

再来看看生产者的代码， EventProducer继承自Producer。

Producer.java

package com.gravel.demo.test.disruptor.base;

/**
 * @Auther: syh
 * @Date: 2020/7/9
 * @Description:
 */
public interface Producer<T> {
    void produce(T t);
}

　　

EventProducer.java

package com.gravel.demo.test.disruptor.base;

import com.lmax.disruptor.RingBuffer;

/**
 * @Auther: syh
 * @Date: 2020/7/9
 * @Description:
 */
public class EventProducer<T> implements Producer<T> {
    private String name;
    private RingBuffer<Event<T>> ringBuffer;
    private EventTranslator<T> translator;
    public EventProducer(String name) {
        this.name = name;
    }

    public EventProducer<T> setRingBuffer(RingBuffer<Event<T>> ringBuffer) {
        this.ringBuffer = ringBuffer;
        return this;
    }

    public EventProducer<T> setTranslator(EventTranslator<T> translator) {
        this.translator = translator;
        return this;
    }

    @Override
    public void produce(T t) {
        System.out.println(String.format("producer message by %s, data: %s", name, t));
        if (translator != null) {
            ringBuffer.publishEvent(translator, t);
        } else {
            long seq = ringBuffer.next();
            try {
                Event<T> event = ringBuffer.get(seq);
                event.set(t);
            } finally {
                // Disruptor 要求 RingBuffer.publish 必须得到调用的潜台词就是，如果发生异常也一样要调用 publish
                // 如果某个请求的 sequence 未被提交，将会堵塞后续的发布操作或者其它的 producer
                ringBuffer.publish(seq);
            }
        }
    }
}

　　

其中，ringBuffer必须是Disruptor实例的成员。所以在指定producer时必须遍历设置ringBuffer。translator对象也做单例模式不知道是否会发生线程间数据覆盖问题。如果线程不安全，就每个Producer都初始化一个Translator对象。从produce()方法我们可以看见，disruptor是通过ringBuffer发布消息的。有两种发布方式：一种是通过translator方式，一种是通过sequence方式。注意finally里面的提示。

来看看EventTranslator的代码,继承自EventTranslatorVararg，translateTo()方法对EventFactory创建的实例做数据填充。

package com.gravel.demo.test.disruptor.base;

import com.lmax.disruptor.EventTranslatorVararg;

/**
 * @Auther: syh
 * @Date: 2020/7/9
 * @Description:
 */
public class EventTranslator<T> implements EventTranslatorVararg<Event<T>> {

    @Override
    public void translateTo(Event<T> event, long sequence, Object... args) {
        event.set(((T)(args[0])));
    }
}

　　

然后是消费者。为了统一处理worker和handler结果，所有的消费者必须实现Disruptor的EventHandler/WorkHandler。还有一个自定义的Consumer接口。

Consumer接口

package com.gravel.demo.test.disruptor.base;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public interface Consumer<T> {
    void consume(T data, Boolean over) throws Exception;
}

　　

EventConsumer.java

package com.gravel.demo.test.disruptor.base;

import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.WorkHandler;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public abstract class EventConsumer<T> implements EventHandler<Event<T>>, Consumer<T>, WorkHandler<Event<T>> {
    String name;

    public EventConsumer(String name) {
        this.name = name;
    }

    @Override
    public void onEvent(Event<T> event, long seq, boolean over) throws Exception {
        consume(event.get(), over);
    }

    @Override
    public void onEvent(Event<T> event) throws Exception {
        consume(event.get(), null);
    }

    protected String getName() {
        return name;
    }
}

　　

抽象类EventConsumer统一处理worker和handler的onEvent方法。具体的consume操作需要用户自己实现。如demo里面的DomainConsumer。

到这里。比较关键的生产者和消费者代码都封装好了。

现在看看非核心代码

错误处理类：ErrorHandler实现ExceptionHandler

package com.gravel.demo.test.disruptor.base;

import com.lmax.disruptor.ExceptionHandler;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public abstract class ErrorHandler<T> implements ExceptionHandler<Event<T>> {
    @Override
    public void handleEventException(Throwable throwable, long l, Event<T> t) {
        handle(t.get(), throwable);
    }

    @Override
    public void handleOnStartException(Throwable throwable) {
    }

    @Override
    public void handleOnShutdownException(Throwable throwable) {
    }

    protected abstract void handle(T object, Throwable throwable);
}

　　

EventFactory事件工厂类，实现Disruptor的EeventFactory

package com.gravel.demo.test.disruptor.base;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public class EventFactory implements com.lmax.disruptor.EventFactory {

    @Override
    public Event newInstance() {
        return new Event();
    }
}

　　

ringBuffer发送方式

package com.gravel.demo.test.disruptor.base;

/**
 * @Auther: syh
 * @Date: 2020/7/9
 * @Description:
 */
public enum  PublishStrategy {
    NORMAL, TRANSLATOR
}

　　

至此，Disruptor的封装就结束了。放一下demo类

实体Domain

package com.gravel.demo.test.disruptor;

/**
 * @Auther: syh
 * @Date: 2020/7/9
 * @Description:
 */
public class Domain {

    private String id;
    private String value;

    public Domain(String id, String value) {
        this.id = id;
        this.value = value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Domain{" +
                "id='" + id + '\'' +
                ", value='" + value + '\'' +
                '}';
    }
}

　　

DomainConsumer

package com.gravel.demo.test.disruptor;

import com.gravel.demo.test.disruptor.base.EventConsumer;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public class DomainConsumer extends EventConsumer<Domain> {

    public DomainConsumer() {
        this("FirstDisruptorHandler" + (Math.random() * 100));
    }

    public DomainConsumer(String name) {
        super(name);
    }

    @Override
    public void consume(Domain data, Boolean over) throws Exception {
        // errorHandler测试用：worker抛异常，handler正常处理
        /*if (Objects.isNull(over)) {
            throw new RuntimeException(getName() + " handle exception.");
        }*/

        System.out.println(String.format("received by %s, data: %s, is over?%s", getName(), data.toString(), over));
        data.setValue(getName());
    }
}

　　

ConsumerErrorHandler

package com.gravel.demo.test.disruptor;

import com.gravel.demo.test.disruptor.base.ErrorHandler;

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description:
 */
public class DomainErrorHandler<T> extends ErrorHandler<T> {
    @Override
    protected void handle(T object, Throwable throwable) {
        System.err.println(String.format("received a error message: %s, data: %s, ", throwable.getMessage(), object));
        // 不抛异常，则数据会继续流转到下一个handler
        throw new IllegalStateException("interrupted.");
    }
}

　　

LimitThreadFactory

package com.gravel.demo.test.disruptor;

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

/**
 * @Auther: syh
 * @Date: 2020/7/8
 * @Description: 单线程
 */
public class LimitedThreadFactory implements ThreadFactory {
    private final AtomicInteger count = new AtomicInteger(0);

    public Thread newThread(Runnable r) {
        if (count.compareAndSet(0, 1)) {
            return new Thread(r);
        } else {
            throw new IllegalStateException("Created more that one thread");
        }
    }
}

　

demo测试（只测一条消费数据）

单生产单消费(worker和handler调用结果一致)

.producer(producer1)
.handler(handler1)

　　

调用结果

producer message by producer1, data: Domain{id='0', value='init'}
received by handler1, data: Domain{id='0', value='init'}, is over?true
used time: 19ms

　　

单生产者多消费者(hanlder类型，设置菱形调用链。)。

.producer(producer1)
.handler(handler1, handler2)
.after(handler1).handler(after1)
.after(handler2).handler(after2)
.after(after1, after2).handler(after3)

　　

调用结果(event数据会被每个handler都消费。)　

producer message by producer1, data: Domain{id='0', value='init'}
received by handler2, data: Domain{id='0', value='init'}, is over?true
received by handler1, data: Domain{id='0', value='init'}, is over?true
received by after2, data: Domain{id='0', value='handler1'}, is over?true
received by after1, data: Domain{id='0', value='handler1'}, is over?true
received by after3, data: Domain{id='0', value='after1'}, is over?true
used time: 19ms

　　

单线程 ，单生产者多消费者(worker类型，work类型不能直接设置after。)。

.producer(producer1)
.worker(handler1, handler2)

　　　

调用结果（对比handler，可以看出event数据只会被一个worker消费。）

producer message by producer1, data: Domain{id='0', value='init'}
received by handler1, data: Domain{id='0', value='init'}, is over?null
used time: 21ms

　　

多生产单消费（work和handler一致）

.handler(handler1)
.producer(producer1, producer2)

　　

运行结果(数据被改写了)

producer message by producer1, data: Domain{id='0', value='init'}
producer message by producer2, data: Domain{id='0', value='init'}
received by handler1, data: Domain{id='0', value='init'}, is over?true
received by handler1, data: Domain{id='0', value='handler1'}, is over?true
used time: 18ms

　　

多生产多消费（worker和handler混合用)

.producer(producer1, producer2)
.worker(after1, after2)
.handler(handler1, handler2)

　　　

调用结果

producer message by producer1, data: Domain{id='0', value='init'}
producer message by producer2, data: Domain{id='0', value='init'}
received by after2, data: Domain{id='0', value='init'}, is over?null
received by after1, data: Domain{id='0', value='after2'}, is over?null
received by handler2, data: Domain{id='0', value='after1'}, is over?false
received by handler1, data: Domain{id='0', value='after1'}, is over?false
received by handler2, data: Domain{id='0', value='handler2'}, is over?true
received by handler1, data: Domain{id='0', value='handler1'}, is over?true
used time: 26ms