public class ThrottlingFilter implements javax.servlet.Filter {
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        HttpSession session = httpRequest.getSession(true);

        Bucket bucket = (Bucket) session.getAttribute("throttler");
        if (bucket == null) {
            // build bucket with required capacity and associate it with particular user
            bucket = Buckets.withNanoTimePrecision()
                .withLimitedBandwidth(10, TimeUnit.SECONDS, 1)
                .build();
            session.setAttribute("throttler", bucket);
        }

        // tryConsumeSingleToken returns false immediately if no tokens available with the bucket
        if (bucket.tryConsumeSingleToken()) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
            httpResponse.setContentType("text/plain");
            httpResponse.setStatus(429);
            httpResponse.getWriter().append("Too many requests");
        }
    }

}

// Create a token bucket with required capacity.
Bucket bucket = Buckets.withNanoTimePrecision()
                .withLimitedBandwidth(100, TimeUnit.MINUTES, 1)
                .build();

// ...
while (true) {
  // Consume a token from the token bucket.  
  // If a token is not available this method will block until
  // the refill adds one to the bucket.
  bucket.consume(1);

  poll();
}

Bucket bucket = Buckets.withNanoTimePrecision()
       // allows 1000 tokens per 1 minute
       .withLimitedBandwidth(1000, TimeUnit.MINUTES, 1)
       // but not often then 50 tokens per 1 second
       .withLimitedBandwidth(50, TimeUnit.SECOND, 1)
       .build();

// ...
while (true) {
  // Consume a token from the token bucket.  If a token is not available this method will block until
  // the refill adds one to the bucket.
  bucket.consume(1);

  workloadExecutor.execute(new LoadTask());
}

Bucket bucket = Buckets.withNanoTimePrecision()
    .withLimitedBandwidth(1000, TimeUnit.HOURS, 1)
    .withGuaranteedBandwidth(1, TimeUnit.MINUTES, 10)
    .build();

int initialCapacity = 42;

Bucket bucket = Buckets.withNanoTimePrecision()
    .withLimitedBandwidth(1000, TimeUnit.HOURS, 1, initialCapacity)
    .build();

BandwidthAdjuster adjuster = new BandwidthAdjuster() {
    @Override
    public long getCapacity(long currentTime) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(currentTime);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        if (hour >= 7 && hour <= 23) {
            return 10;    
        } else {
            return 2;
        }
    }
};
Buckets.withMillisTimePrecision()
    .withLimitedBandwidth(adjuster, TimeUnit.MINUTES, 1, 10);

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class CurrentThreadCpuTimeMeter implements TimeMeter {

    private static final ThreadMXBean THREAD_MX_BEAN = ManagementFactory.getThreadMXBean();

    @Override
    public long currentTime() {
        return THREAD_MX_BEAN.getCurrentThreadCpuTime();
    }

    @Override
    public void sleep(long units) throws InterruptedException {
        LockSupport.parkNanos(units);
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
    }

    @Override
    public long toBandwidthPeriod(TimeUnit timeUnit, long period) {
        return timeUnit.toNanos(period);
    }

}

Bucket bucket = Buckets.withCustomTimePrecision(new CurrentThreadCpuTimeMeter())
                .withLimitedBandwidth(100, TimeUnit.MINUTES, 1)
                .build();

// Cache with name "my_buckets" should be configured as described in the documentation for Oracle Coherence.  
NamedCache cache = com.tangosol.net.CacheFactory.getCache("my_buckets");

// Bucket will be stored in the cache by this ID 
Object bucketId = "42";

// construct bucket
Bucket bucket = Buckets.withMillisTimePrecision()
                .withLimitedBandwidth(100, TimeUnit.MINUTES, 1)
                .buildCoherence(cache, bucketId);

  
HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance();

// In opposite to Coherence, Hazelcast does not require to configure cache before using it,
// but it would be better to configure map "my_buckets" as described in Hazelcast documentation,
// because Hazelcast enables backups by default, and backup feature leads to performance degradation. 
IMap<Object, GridBucketState> imap = hazelcastInstance.getMap("my_buckets");

// Bucket will be stored in the imap by this ID 
Object bucketId = "666";

// construct bucket
Bucket bucket = Buckets.withMillisTimePrecision()
                .withLimitedBandwidth(100, TimeUnit.MINUTES, 1)
                .buildHazelcast(imap, bucketId);

Ignite ignite = Ignition.start();
...

// You can use spring configuration if do not want to configure cache in the java code  
CacheConfiguration cfg = new CacheConfiguration("my_buckets");

// setup cache configuration as you wish
cfg.setXXX...
cache = ignite.getOrCreateCache(cfg);

// Bucket will be stored in the Ignite cache by this ID 
Object bucketId = "21";

// construct bucket
Bucket bucket = Buckets.withMillisTimePrecision()
                .withLimitedBandwidth(100, TimeUnit.MINUTES, 1)
                .buildIgnite(cache, bucketId);