import com.google.common.base.Preconditions;

import org.apache.commons.lang3.math.NumberUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

 * 若Runable执行的时间超过 MAX_QPS / qps，则实际的QPS会低于实际的值。

 */

public class QpsProxy {

    private final Logger logger = LoggerFactory.getLogger(QpsProxy.class);

    private final static int MAX_QPS = 1000;

    private ScheduledExecutorService scheduledExecutorService;

    private long qps = NumberUtils.LONG_ONE;

    private Runnable runnable;

    private long delay2Start = NumberUtils.INTEGER_ZERO;

    private int threads = 10;

    public QpsProxy() {

    }

    public ScheduledExecutorService getScheduledExecutorService() {

        return scheduledExecutorService;

    }

    public void setScheduledExecutorService(ScheduledExecutorService scheduledExecutorService) {

        this.scheduledExecutorService = scheduledExecutorService;

    }

    public long getQps() {

        return qps;

    }

    public void setQps(long qps) {

        Preconditions.checkArgument(qps < MAX_QPS , "设置的qps超过上限值:" + MAX_QPS);

        this.qps = qps;

    }

    public Runnable getRunnable() {

        return runnable;

    }

    public void setRunnable(Runnable runnable) {

        this.runnable = runnable;

    }

    public long getDelay2Start() {

        return delay2Start;

    }

    public void setDelay2Start(long delay2Start) {

        this.delay2Start = delay2Start;

    }

    public int getThreads() {

        return threads;

    }

    public void setThreads(int threads) {

        this.threads = threads;

    }

    public void start() {

        Preconditions.checkNotNull(runnable, "请设置执行的任务");

        long period = (long) Math.floor((double) MAX_QPS / qps);

        logger.info("间隔周期:{}ms", period);

        scheduledExecutorService = Executors.newScheduledThreadPool(threads);

        scheduledExecutorService.scheduleAtFixedRate(runnable, delay2Start,

                period, TimeUnit.MILLISECONDS);

    }

    public void stop() {

        Preconditions.checkNotNull(scheduledExecutorService, "任务未开始");

        scheduledExecutorService.shutdown();

    }

}

import com.google.common.base.Preconditions;

public class QpsProxyBuilder {

    private QpsProxy qpsProxy = new QpsProxy();

    public static QpsProxyBuilder newBuilder() {

        return new QpsProxyBuilder();

    }

    public QpsProxyBuilder withDelay2Start(long delay2TimeByMillisSeconds) {

        Preconditions.checkArgument(delay2TimeByMillisSeconds > 0);

        qpsProxy.setDelay2Start(delay2TimeByMillisSeconds);

        return this;

    }

    public QpsProxyBuilder withQps(long qps) {

        Preconditions.checkArgument(qps > 0);

        qpsProxy.setQps(qps);

        return this;

    }

    public QpsProxyBuilder withRunnable(Runnable runnable) {

        Preconditions.checkNotNull(runnable);

        qpsProxy.setRunnable(runnable);

        return this;

    }

    public QpsProxyBuilder withThreads(int threads) {

        Preconditions.checkNotNull(threads > 0);

        qpsProxy.setThreads(threads);

        return this;

    }

    public QpsProxy build() {

        return qpsProxy;

    }

}

import com.qunar.hotel.qps.QpsProxy;

import com.qunar.hotel.qps.QpsProxyBuilder;

import org.junit.Test;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class qps {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Test

    public void testBasic() throws InterruptedException {

        QpsProxy proxy = QpsProxyBuilder.newBuilder().withQps(100).withThreads(1).withDelay2Start(4000).withRunnable(new Runnable() {

            private int counter = 0;

            @Override

            public void run() {

                logger.info("{}-{}:{}", Thread.currentThread().getName(), System.nanoTime(), counter++);

            }

        }).build();

        proxy.start();

        Thread.currentThread().sleep(5020L);

        proxy.stop();

    }

}