วิธีการควบคุมปริมาณเรียกร้องไปยังคำขอ M ใน N วินาที

Question 1

ฉันต้องการคอมโพเนนต์ / คลาสที่ควบคุมการดำเนินการของวิธีการบางอย่างเพื่อเรียก M สูงสุดใน N วินาที (หรือ ms หรือนาโนไม่สำคัญ)

กล่าวอีกนัยหนึ่งฉันต้องแน่ใจว่าวิธีการของฉันดำเนินการไม่เกิน M ครั้งในหน้าต่างบานเลื่อนที่ N วินาที

หากคุณไม่ทราบว่าชั้นเรียนที่มีอยู่โปรดโพสต์วิธีแก้ปัญหา / แนวคิดของคุณว่าคุณจะนำสิ่งนี้ไปใช้อย่างไร

Question 2

ฉันจะใช้บัฟเฟอร์วงแหวนของการประทับเวลาที่มีขนาดคงที่ของ M ทุกครั้งที่มีการเรียกวิธีนี้คุณจะตรวจสอบรายการที่เก่าที่สุดและถ้าน้อยกว่า N วินาทีในอดีตคุณจะดำเนินการและเพิ่มรายการอื่นมิฉะนั้นคุณจะเข้าสู่โหมดสลีป สำหรับความแตกต่างของเวลา

Question 3

สิ่งที่ทำงานออกจากกล่องสำหรับฉันคือ Google ฝรั่งRateLimiter

// Allow one request per second
private RateLimiter throttle = RateLimiter.create(1.0);

private void someMethod() {
    throttle.acquire();
    // Do something
}

Question 4

ในแง่ที่เป็นรูปธรรมคุณควรจะสามารถใช้สิ่งนี้ได้ด้วยไฟล์DelayQueue. เริ่มต้นคิวด้วยM Delayedอินสแตนซ์โดยตั้งค่าความล่าช้าเป็นศูนย์ในตอนแรก เมื่อมีการร้องขอไปยังเมธอดจะtakeมีโทเค็นซึ่งทำให้เมธอดบล็อกจนกว่าจะตรงตามข้อกำหนดการควบคุมปริมาณ เมื่อโทเค็นได้รับการถ่าย, โทเค็นใหม่ในคิวที่มีความล่าช้าของaddN

Question 5

อ่านอัลกอริธึมถัง Token โดยทั่วไปคุณมีถังที่มีโทเค็นอยู่ในนั้น ทุกครั้งที่คุณดำเนินการตามวิธีนี้คุณจะต้องใช้โทเค็น หากไม่มีโทเค็นอีกคุณจะบล็อกจนกว่าจะได้มา ในขณะเดียวกันก็มีนักแสดงภายนอกบางคนที่เติมโทเค็นในช่วงเวลาที่กำหนด

ฉันไม่รู้ว่ามีห้องสมุดให้ทำสิ่งนี้ (หรืออะไรที่คล้ายกัน) คุณสามารถเขียนตรรกะนี้ลงในโค้ดของคุณหรือใช้ AspectJ เพื่อเพิ่มลักษณะการทำงาน

Question 6

หากคุณต้องการตัว จำกัด อัตราหน้าต่างบานเลื่อนที่ใช้ Java ซึ่งจะทำงานในระบบกระจายคุณอาจต้องการดูที่https://github.com/mokies/ratelimitjโครงการ

การกำหนดค่าที่สำรองไว้ของ Redis เพื่อ จำกัด คำขอตาม IP ถึง 50 ต่อนาทีจะมีลักษณะดังนี้:

import com.lambdaworks.redis.RedisClient;
import es.moki.ratelimitj.core.LimitRule;

RedisClient client = RedisClient.create("redis://localhost");
Set<LimitRule> rules = Collections.singleton(LimitRule.of(1, TimeUnit.MINUTES, 50)); // 50 request per minute, per key
RedisRateLimit requestRateLimiter = new RedisRateLimit(client, rules);

boolean overLimit = requestRateLimiter.overLimit("ip:127.0.0.2");

ดูhttps://github.com/mokies/ratelimitj/tree/master/ratelimitj-redis สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการกำหนดค่า Redis

Question 7

ขึ้นอยู่กับการใช้งาน

ลองนึกภาพกรณีที่เธรดหลายเธรดต้องการให้โทเค็นทำการกระทำที่ จำกัด อัตราทั่วโลกโดยไม่อนุญาตให้มีการต่อเนื่อง (เช่นคุณต้องการ จำกัด 10 การกระทำต่อ 10 วินาที แต่คุณไม่ต้องการให้ 10 การกระทำเกิดขึ้นในวินาทีแรกและจากนั้นคงอยู่ หยุด 9 วินาที)

DelayedQueue มีข้อเสีย: ลำดับที่เธรดขอโทเค็นอาจไม่ใช่ลำดับที่พวกเขาได้รับการดำเนินการตามคำขอ หากเธรดหลายเธรดถูกบล็อกเพื่อรอโทเค็นจะไม่ชัดเจนว่าอันใดจะใช้โทเค็นถัดไปที่มี คุณอาจมีกระทู้รอตลอดไปในมุมมองของฉัน

วิธีแก้ปัญหาอย่างหนึ่งคือต้องมีช่วงเวลาขั้นต่ำระหว่างการดำเนินการสองครั้งติดต่อกันและดำเนินการตามลำดับเดียวกันกับที่ร้องขอ

นี่คือการนำไปใช้:

public class LeakyBucket {
    protected float maxRate;
    protected long minTime;
    //holds time of last action (past or future!)
    protected long lastSchedAction = System.currentTimeMillis();

    public LeakyBucket(float maxRate) throws Exception {
        if(maxRate <= 0.0f) {
            throw new Exception("Invalid rate");
        }
        this.maxRate = maxRate;
        this.minTime = (long)(1000.0f / maxRate);
    }

    public void consume() throws InterruptedException {
        long curTime = System.currentTimeMillis();
        long timeLeft;

        //calculate when can we do the action
        synchronized(this) {
            timeLeft = lastSchedAction + minTime - curTime;
            if(timeLeft > 0) {
                lastSchedAction += minTime;
            }
            else {
                lastSchedAction = curTime;
            }
        }

        //If needed, wait for our time
        if(timeLeft <= 0) {
            return;
        }
        else {
            Thread.sleep(timeLeft);
        }
    }
}

Question 8

แม้ว่าจะไม่ใช่สิ่งที่คุณถามThreadPoolExecutorซึ่งออกแบบมาเพื่อตอบสนองคำขอพร้อมกัน M แทนที่จะเป็นคำขอ M ใน N วินาทีก็อาจมีประโยชน์เช่นกัน

Question 9

ฉันได้ใช้อัลกอริธึมการควบคุมปริมาณอย่างง่ายลองใช้ลิงค์นี้ http://krishnaprasadas.blogspot.in/2012/05/throttling-algorithm.html

ข้อมูลสั้น ๆ เกี่ยวกับอัลกอริทึม

ขั้นตอนวิธีการนี้จะใช้ความสามารถของ Java ล่าช้าคิว สร้างออบเจ็กต์ที่ล่าช้าโดยมีการหน่วงเวลาที่คาดไว้ (ที่นี่ 1000 / M สำหรับมิลลิวินาทีสำหรับTimeUnit ) ใส่วัตถุเดียวกันลงในคิวที่ล่าช้าซึ่งจะช่วยให้หน้าต่างเคลื่อนที่สำหรับเรา จากนั้นก่อนที่แต่ละเมธอดจะใช้อ็อบเจ็กต์ในรูปแบบคิว take คือการเรียกบล็อคซึ่งจะส่งคืนหลังจากความล่าช้าที่ระบุเท่านั้นและหลังจากการเรียกใช้เมธอดอย่าลืมใส่อ็อบเจ็กต์ลงในคิวด้วยเวลาที่อัปเดต (ในที่นี้เป็นมิลลิวินาทีปัจจุบัน) .

นอกจากนี้เรายังสามารถมีวัตถุล่าช้าหลายรายการที่มีความล่าช้าต่างกัน วิธีนี้จะให้ปริมาณงานสูงด้วย

Question 10

การใช้งานของฉันด้านล่างสามารถจัดการความแม่นยำของเวลาในการร้องขอโดยพลการมีความซับซ้อนของเวลา O (1) สำหรับแต่ละคำขอไม่ต้องการบัฟเฟอร์เพิ่มเติมใด ๆ เช่นความซับซ้อนของพื้นที่ O (1) นอกจากนี้ยังไม่ต้องใช้เธรดพื้นหลังเพื่อปล่อยโทเค็นแทน โทเค็นจะถูกปล่อยตามเวลาที่ผ่านไปนับตั้งแต่คำขอล่าสุด

class RateLimiter {
    int limit;
    double available;
    long interval;

    long lastTimeStamp;

    RateLimiter(int limit, long interval) {
        this.limit = limit;
        this.interval = interval;

        available = 0;
        lastTimeStamp = System.currentTimeMillis();
    }

    synchronized boolean canAdd() {
        long now = System.currentTimeMillis();
        // more token are released since last request
        available += (now-lastTimeStamp)*1.0/interval*limit; 
        if (available>limit)
            available = limit;

        if (available<1)
            return false;
        else {
            available--;
            lastTimeStamp = now;
            return true;
        }
    }
}

Question 11

ลองใช้แนวทางง่ายๆนี้:

public class SimpleThrottler {

private static final int T = 1; // min
private static final int N = 345;

private Lock lock = new ReentrantLock();
private Condition newFrame = lock.newCondition();
private volatile boolean currentFrame = true;

public SimpleThrottler() {
    handleForGate();
}

/**
 * Payload
 */
private void job() {
    try {
        Thread.sleep(Math.abs(ThreadLocalRandom.current().nextLong(12, 98)));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.err.print(" J. ");
}

public void doJob() throws InterruptedException {
    lock.lock();
    try {

        while (true) {

            int count = 0;

            while (count < N && currentFrame) {
                job();
                count++;
            }

            newFrame.await();
            currentFrame = true;
        }

    } finally {
        lock.unlock();
    }
}

public void handleForGate() {
    Thread handler = new Thread(() -> {
        while (true) {
            try {
                Thread.sleep(1 * 900);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                currentFrame = false;

                lock.lock();
                try {
                    newFrame.signal();
                } finally {
                    lock.unlock();
                }
            }
        }
    });
    handler.start();
}

}

Question 12

Apache Camelยังมาพร้อมกับกลไกThrottlerดังต่อไปนี้:

from("seda:a").throttle(100).asyncDelayed().to("seda:b");

Question 13

นี่เป็นการอัปเดตโค้ด LeakyBucket ด้านบน วิธีนี้ใช้ได้กับคำขอมากกว่า 1,000 คำขอต่อวินาที

import lombok.SneakyThrows;
import java.util.concurrent.TimeUnit;

class LeakyBucket {
  private long minTimeNano; // sec / billion
  private long sched = System.nanoTime();

  /**
   * Create a rate limiter using the leakybucket alg.
   * @param perSec the number of requests per second
   */
  public LeakyBucket(double perSec) {
    if (perSec <= 0.0) {
      throw new RuntimeException("Invalid rate " + perSec);
    }
    this.minTimeNano = (long) (1_000_000_000.0 / perSec);
  }

  @SneakyThrows public void consume() {
    long curr = System.nanoTime();
    long timeLeft;

    synchronized (this) {
      timeLeft = sched - curr + minTimeNano;
      sched += minTimeNano;
    }
    if (timeLeft <= minTimeNano) {
      return;
    }
    TimeUnit.NANOSECONDS.sleep(timeLeft);
  }
}

และ unittest สำหรับด้านบน:

import com.google.common.base.Stopwatch;
import org.junit.Ignore;
import org.junit.Test;

import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

public class LeakyBucketTest {
  @Test @Ignore public void t() {
    double numberPerSec = 10000;
    LeakyBucket b = new LeakyBucket(numberPerSec);
    Stopwatch w = Stopwatch.createStarted();
    IntStream.range(0, (int) (numberPerSec * 5)).parallel().forEach(
        x -> b.consume());
    System.out.printf("%,d ms%n", w.elapsed(TimeUnit.MILLISECONDS));
  }
}

Question 14

นี่คือตัว จำกัด อัตราขั้นสูงเพียงเล็กน้อย

/**
 * Simple request limiter based on Thread.sleep method.
 * Create limiter instance via {@link #create(float)} and call {@link #consume()} before making any request.
 * If the limit is exceeded cosume method locks and waits for current call rate to fall down below the limit
 */
public class RequestRateLimiter {

    private long minTime;

    private long lastSchedAction;
    private double avgSpent = 0;

    ArrayList<RatePeriod> periods;


    @AllArgsConstructor
    public static class RatePeriod{

        @Getter
        private LocalTime start;

        @Getter
        private LocalTime end;

        @Getter
        private float maxRate;
    }


    /**
     * Create request limiter with maxRate - maximum number of requests per second
     * @param maxRate - maximum number of requests per second
     * @return
     */
    public static RequestRateLimiter create(float maxRate){
        return new RequestRateLimiter(Arrays.asList( new RatePeriod(LocalTime.of(0,0,0),
                LocalTime.of(23,59,59), maxRate)));
    }

    /**
     * Create request limiter with ratePeriods calendar - maximum number of requests per second in every period
     * @param ratePeriods - rate calendar
     * @return
     */
    public static RequestRateLimiter create(List<RatePeriod> ratePeriods){
        return new RequestRateLimiter(ratePeriods);
    }

    private void checkArgs(List<RatePeriod> ratePeriods){

        for (RatePeriod rp: ratePeriods ){
            if ( null == rp || rp.maxRate <= 0.0f || null == rp.start || null == rp.end )
                throw new IllegalArgumentException("list contains null or rate is less then zero or period is zero length");
        }
    }

    private float getCurrentRate(){

        LocalTime now = LocalTime.now();

        for (RatePeriod rp: periods){
            if ( now.isAfter( rp.start ) && now.isBefore( rp.end ) )
                return rp.maxRate;
        }

        return Float.MAX_VALUE;
    }



    private RequestRateLimiter(List<RatePeriod> ratePeriods){

        checkArgs(ratePeriods);
        periods = new ArrayList<>(ratePeriods.size());
        periods.addAll(ratePeriods);

        this.minTime = (long)(1000.0f / getCurrentRate());
        this.lastSchedAction = System.currentTimeMillis() - minTime;
    }

    /**
     * Call this method before making actual request.
     * Method call locks until current rate falls down below the limit
     * @throws InterruptedException
     */
    public void consume() throws InterruptedException {

        long timeLeft;

        synchronized(this) {
            long curTime = System.currentTimeMillis();

            minTime = (long)(1000.0f / getCurrentRate());
            timeLeft = lastSchedAction + minTime - curTime;

            long timeSpent = curTime - lastSchedAction + timeLeft;
            avgSpent = (avgSpent + timeSpent) / 2;

            if(timeLeft <= 0) {
                lastSchedAction = curTime;
                return;
            }

            lastSchedAction = curTime + timeLeft;
        }

        Thread.sleep(timeLeft);
    }

    public synchronized float getCuRate(){
        return (float) ( 1000d / avgSpent);
    }
}

และแบบทดสอบหน่วย

import org.junit.Assert;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class RequestRateLimiterTest {


    @Test(expected = IllegalArgumentException.class)
    public void checkSingleThreadZeroRate(){

        // Zero rate
        RequestRateLimiter limiter = RequestRateLimiter.create(0);
        try {
            limiter.consume();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void checkSingleThreadUnlimitedRate(){

        // Unlimited
        RequestRateLimiter limiter = RequestRateLimiter.create(Float.MAX_VALUE);

        long started = System.currentTimeMillis();
        for ( int i = 0; i < 1000; i++ ){

            try {
                limiter.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long ended = System.currentTimeMillis();
        System.out.println( "Current rate:" + limiter.getCurRate() );
        Assert.assertTrue( ((ended - started) < 1000));
    }

    @Test
    public void rcheckSingleThreadRate(){

        // 3 request per minute
        RequestRateLimiter limiter = RequestRateLimiter.create(3f/60f);

        long started = System.currentTimeMillis();
        for ( int i = 0; i < 3; i++ ){

            try {
                limiter.consume();
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long ended = System.currentTimeMillis();

        System.out.println( "Current rate:" + limiter.getCurRate() );
        Assert.assertTrue( ((ended - started) >= 60000 ) & ((ended - started) < 61000));
    }



    @Test
    public void checkSingleThreadRateLimit(){

        // 100 request per second
        RequestRateLimiter limiter = RequestRateLimiter.create(100);

        long started = System.currentTimeMillis();
        for ( int i = 0; i < 1000; i++ ){

            try {
                limiter.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long ended = System.currentTimeMillis();

        System.out.println( "Current rate:" + limiter.getCurRate() );
        Assert.assertTrue( (ended - started) >= ( 10000 - 100 ));
    }

    @Test
    public void checkMultiThreadedRateLimit(){

        // 100 request per second
        RequestRateLimiter limiter = RequestRateLimiter.create(100);
        long started = System.currentTimeMillis();

        List<Future<?>> tasks = new ArrayList<>(10);
        ExecutorService exec = Executors.newFixedThreadPool(10);

        for ( int i = 0; i < 10; i++ ) {

            tasks.add( exec.submit(() -> {
                for (int i1 = 0; i1 < 100; i1++) {

                    try {
                        limiter.consume();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }) );
        }

        tasks.stream().forEach( future -> {
            try {
                future.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

        long ended = System.currentTimeMillis();
        System.out.println( "Current rate:" + limiter.getCurRate() );
        Assert.assertTrue( (ended - started) >= ( 10000 - 100 ) );
    }

    @Test
    public void checkMultiThreaded32RateLimit(){

        // 0,2 request per second
        RequestRateLimiter limiter = RequestRateLimiter.create(0.2f);
        long started = System.currentTimeMillis();

        List<Future<?>> tasks = new ArrayList<>(8);
        ExecutorService exec = Executors.newFixedThreadPool(8);

        for ( int i = 0; i < 8; i++ ) {

            tasks.add( exec.submit(() -> {
                for (int i1 = 0; i1 < 2; i1++) {

                    try {
                        limiter.consume();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }) );
        }

        tasks.stream().forEach( future -> {
            try {
                future.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

        long ended = System.currentTimeMillis();
        System.out.println( "Current rate:" + limiter.getCurRate() );
        Assert.assertTrue( (ended - started) >= ( 10000 - 100 ) );
    }

    @Test
    public void checkMultiThreadedRateLimitDynamicRate(){

        // 100 request per second
        RequestRateLimiter limiter = RequestRateLimiter.create(100);
        long started = System.currentTimeMillis();

        List<Future<?>> tasks = new ArrayList<>(10);
        ExecutorService exec = Executors.newFixedThreadPool(10);

        for ( int i = 0; i < 10; i++ ) {

            tasks.add( exec.submit(() -> {

                Random r = new Random();
                for (int i1 = 0; i1 < 100; i1++) {

                    try {
                        limiter.consume();
                        Thread.sleep(r.nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }) );
        }

        tasks.stream().forEach( future -> {
            try {
                future.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

        long ended = System.currentTimeMillis();
        System.out.println( "Current rate:" + limiter.getCurRate() );
        Assert.assertTrue( (ended - started) >= ( 10000 - 100 ) );
    }

}

Question 15

วิธีแก้ปัญหาของฉัน: วิธีการใช้งานง่ายๆคุณสามารถปรับเปลี่ยนเพื่อสร้างคลาส Wrapper ได้

public static Runnable throttle (Runnable realRunner, long delay) {
    Runnable throttleRunner = new Runnable() {
        // whether is waiting to run
        private boolean _isWaiting = false;
        // target time to run realRunner
        private long _timeToRun;
        // specified delay time to wait
        private long _delay = delay;
        // Runnable that has the real task to run
        private Runnable _realRunner = realRunner;
        @Override
        public void run() {
            // current time
            long now;
            synchronized (this) {
                // another thread is waiting, skip
                if (_isWaiting) return;
                now = System.currentTimeMillis();
                // update time to run
                // do not update it each time since
                // you do not want to postpone it unlimited
                _timeToRun = now+_delay;
                // set waiting status
                _isWaiting = true;
            }
            try {
                Thread.sleep(_timeToRun-now);

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // clear waiting status before run
                _isWaiting = false;
                // do the real task
                _realRunner.run();
            }
        }};
    return throttleRunner;
}

ใช้จากJAVA Thread Debounce และ Throttle