How can I limit bandwidth in Java?

I wrote a Java scheduler, every hour using:

new SAXBuilder().build(new URL(xxx));

HttpConnection.connect(new URL(xxx)); // jsoup library code

to get a big XML/HTML file.

My server maximum bandwidth limit is 2Mbits.

When this Java schedule code runs, I use over 2Mbits of bandwidth. (check it out)

So every time a user visits my server it is too slow.

How do I limit my Java schedule to use lower bandwidth? (ex. 500Kbits)

I am using Ubuntu server.

Solution 1:

There's no elegant way to do this.

A simple but inelegant way would be to write a Java stream wrapper that limits the rate at which bytes are read from the wrapped Stream. For instance, if you wanted to limit to 1000 bytes per second, the int read() method could be implemented as follows:

Stream in;
long timestamp = System.currentTimeInMillis();
int counter = 0;
int INTERVAL = 1000; // one second
int LIMIT = 1000; // bytes per INTERVAL

...

/**
 * Read one byte with rate limiting
 */
@Override
public int read() {
    if (counter > LIMIT) {
        long now = System.currentTimeInMillis();
        if (timestamp + INTERVAL >= now) {
            Thread.sleep(timestamp + INTERVAL - now);  
        }
        timestamp = now;
        counter = 0;
    }
    int res = in.read();
    if (res >= 0) {
        counter++;
    }
    return res;
}

It is worth noting that throttling rates like this can have negative as well as positive effects. On the negative side:

It ties down resources on the server side for longer. In this case, we are talking about the Java thread that is handling the download, and memory in kernel space is used to buffer received network packets until the application reads them.
It may also lead to more network traffic. The problem is that this kind of throttling will disrupt the smooth flow of packets. The server will only buffer a relatively small number of packets, and when that number is exceeded, it has to tell the client to STOP for now. This requires extra signalling packets (ACKs) and there will probably be data packets dropped in the process. Eventually, those data packets will need to be retransmitted.

Solution 2:

Theory:

Token Bucket Algorithm is a way to limit a download's bandwidth. You should read this article : it explains the use of this algorithm.

Implementations:

RateLimiter from Google Guava

Google Guava 22.0 include a RateLimiter class but it is still in beta.

From api documentation:

As an example, imagine that we have a list of tasks to execute, but we don't want to submit more than 2 per second:

final RateLimiter rateLimiter = RateLimiter.create(2.0); // rate is "2 permits per second"
  void submitTasks(List<Runnable> tasks, Executor executor) {
    for (Runnable task : tasks) {
      rateLimiter.acquire(); // may wait
      executor.execute(task);
    }
  }

As another example, imagine that we produce a stream of data, and we want to cap it at 5kb per second. This could be accomplished by requiring a permit per byte, and specifying a rate of 5000 permits per second:

final RateLimiter rateLimiter = RateLimiter.create(5000.0); // rate = 5000 permits per second
  void submitPacket(byte[] packet) {
    rateLimiter.acquire(packet.length);
    networkService.send(packet);
  }

TimedSemaphore from Apache Commons Lang v3

Apache Commons Lang v3 include a TimedSemaphore class that can be used to implement a rate limit.