7becfc5e06
Motivation: We should use OneTimeTask where possible to reduce object creation. Modifications: Replace Runnable with OneTimeTask Result: Less object creation
233 lines
9.0 KiB
Java
233 lines
9.0 KiB
Java
/*
|
|
* Copyright 2012 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.handler.traffic;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
import io.netty.channel.ChannelHandlerContext;
|
|
import io.netty.channel.ChannelPromise;
|
|
import io.netty.util.internal.OneTimeTask;
|
|
|
|
import java.util.ArrayDeque;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
/**
|
|
* <p>This implementation of the {@link AbstractTrafficShapingHandler} is for channel
|
|
* traffic shaping, that is to say a per channel limitation of the bandwidth.</p>
|
|
* <p>Note the index used in {@code OutboundBuffer.setUserDefinedWritability(index, boolean)} is <b>1</b>.</p>
|
|
*
|
|
* <p>The general use should be as follow:</p>
|
|
* <ul>
|
|
* <li><p>Add in your pipeline a new ChannelTrafficShapingHandler.</p>
|
|
* <p><tt>ChannelTrafficShapingHandler myHandler = new ChannelTrafficShapingHandler();</tt></p>
|
|
* <p><tt>pipeline.addLast(myHandler);</tt></p>
|
|
*
|
|
* <p><b>Note that this handler has a Pipeline Coverage of "one" which means a new handler must be created
|
|
* for each new channel as the counter cannot be shared among all channels.</b>.</p>
|
|
*
|
|
* <p>Other arguments can be passed like write or read limitation (in bytes/s where 0 means no limitation)
|
|
* or the check interval (in millisecond) that represents the delay between two computations of the
|
|
* bandwidth and so the call back of the doAccounting method (0 means no accounting at all).</p>
|
|
*
|
|
* <p>A value of 0 means no accounting for checkInterval. If you need traffic shaping but no such accounting,
|
|
* it is recommended to set a positive value, even if it is high since the precision of the
|
|
* Traffic Shaping depends on the period where the traffic is computed. The highest the interval,
|
|
* the less precise the traffic shaping will be. It is suggested as higher value something close
|
|
* to 5 or 10 minutes.</p>
|
|
*
|
|
* <p>maxTimeToWait, by default set to 15s, allows to specify an upper bound of time shaping.</p>
|
|
* </li>
|
|
* <li>In your handler, you should consider to use the {@code channel.isWritable()} and
|
|
* {@code channelWritabilityChanged(ctx)} to handle writability, or through
|
|
* {@code future.addListener(new GenericFutureListener())} on the future returned by
|
|
* {@code ctx.write()}.</li>
|
|
* <li><p>You shall also consider to have object size in read or write operations relatively adapted to
|
|
* the bandwidth you required: for instance having 10 MB objects for 10KB/s will lead to burst effect,
|
|
* while having 100 KB objects for 1 MB/s should be smoothly handle by this TrafficShaping handler.</p></li>
|
|
* <li><p>Some configuration methods will be taken as best effort, meaning
|
|
* that all already scheduled traffics will not be
|
|
* changed, but only applied to new traffics.</p>
|
|
* <p>So the expected usage of those methods are to be used not too often,
|
|
* accordingly to the traffic shaping configuration.</p></li>
|
|
* </ul>
|
|
*/
|
|
public class ChannelTrafficShapingHandler extends AbstractTrafficShapingHandler {
|
|
private final ArrayDeque<ToSend> messagesQueue = new ArrayDeque<ToSend>();
|
|
private long queueSize;
|
|
|
|
/**
|
|
* Create a new instance.
|
|
*
|
|
* @param writeLimit
|
|
* 0 or a limit in bytes/s
|
|
* @param readLimit
|
|
* 0 or a limit in bytes/s
|
|
* @param checkInterval
|
|
* The delay between two computations of performances for
|
|
* channels or 0 if no stats are to be computed.
|
|
* @param maxTime
|
|
* The maximum delay to wait in case of traffic excess.
|
|
*/
|
|
public ChannelTrafficShapingHandler(long writeLimit, long readLimit,
|
|
long checkInterval, long maxTime) {
|
|
super(writeLimit, readLimit, checkInterval, maxTime);
|
|
}
|
|
|
|
/**
|
|
* Create a new instance using default
|
|
* max time as delay allowed value of 15000 ms.
|
|
*
|
|
* @param writeLimit
|
|
* 0 or a limit in bytes/s
|
|
* @param readLimit
|
|
* 0 or a limit in bytes/s
|
|
* @param checkInterval
|
|
* The delay between two computations of performances for
|
|
* channels or 0 if no stats are to be computed.
|
|
*/
|
|
public ChannelTrafficShapingHandler(long writeLimit,
|
|
long readLimit, long checkInterval) {
|
|
super(writeLimit, readLimit, checkInterval);
|
|
}
|
|
|
|
/**
|
|
* Create a new instance using default Check Interval value of 1000 ms and
|
|
* max time as delay allowed value of 15000 ms.
|
|
*
|
|
* @param writeLimit
|
|
* 0 or a limit in bytes/s
|
|
* @param readLimit
|
|
* 0 or a limit in bytes/s
|
|
*/
|
|
public ChannelTrafficShapingHandler(long writeLimit,
|
|
long readLimit) {
|
|
super(writeLimit, readLimit);
|
|
}
|
|
|
|
/**
|
|
* Create a new instance using
|
|
* default max time as delay allowed value of 15000 ms and no limit.
|
|
*
|
|
* @param checkInterval
|
|
* The delay between two computations of performances for
|
|
* channels or 0 if no stats are to be computed.
|
|
*/
|
|
public ChannelTrafficShapingHandler(long checkInterval) {
|
|
super(checkInterval);
|
|
}
|
|
|
|
@Override
|
|
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
|
|
TrafficCounter trafficCounter = new TrafficCounter(this, ctx.executor(), "ChannelTC" +
|
|
ctx.channel().hashCode(), checkInterval);
|
|
setTrafficCounter(trafficCounter);
|
|
trafficCounter.start();
|
|
super.handlerAdded(ctx);
|
|
}
|
|
|
|
@Override
|
|
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
|
|
trafficCounter.stop();
|
|
// write order control
|
|
synchronized (this) {
|
|
if (ctx.channel().isActive()) {
|
|
for (ToSend toSend : messagesQueue) {
|
|
long size = calculateSize(toSend.toSend);
|
|
trafficCounter.bytesRealWriteFlowControl(size);
|
|
queueSize -= size;
|
|
ctx.write(toSend.toSend, toSend.promise);
|
|
}
|
|
} else {
|
|
for (ToSend toSend : messagesQueue) {
|
|
if (toSend.toSend instanceof ByteBuf) {
|
|
((ByteBuf) toSend.toSend).release();
|
|
}
|
|
}
|
|
}
|
|
messagesQueue.clear();
|
|
}
|
|
releaseWriteSuspended(ctx);
|
|
releaseReadSuspended(ctx);
|
|
super.handlerRemoved(ctx);
|
|
}
|
|
|
|
private static final class ToSend {
|
|
final long relativeTimeAction;
|
|
final Object toSend;
|
|
final ChannelPromise promise;
|
|
|
|
private ToSend(final long delay, final Object toSend, final ChannelPromise promise) {
|
|
relativeTimeAction = delay;
|
|
this.toSend = toSend;
|
|
this.promise = promise;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
void submitWrite(final ChannelHandlerContext ctx, final Object msg,
|
|
final long size, final long delay, final long now,
|
|
final ChannelPromise promise) {
|
|
final ToSend newToSend;
|
|
// write order control
|
|
synchronized (this) {
|
|
if (delay == 0 && messagesQueue.isEmpty()) {
|
|
trafficCounter.bytesRealWriteFlowControl(size);
|
|
ctx.write(msg, promise);
|
|
return;
|
|
}
|
|
newToSend = new ToSend(delay + now, msg, promise);
|
|
messagesQueue.addLast(newToSend);
|
|
queueSize += size;
|
|
checkWriteSuspend(ctx, delay, queueSize);
|
|
}
|
|
final long futureNow = newToSend.relativeTimeAction;
|
|
ctx.executor().schedule(new OneTimeTask() {
|
|
@Override
|
|
public void run() {
|
|
sendAllValid(ctx, futureNow);
|
|
}
|
|
}, delay, TimeUnit.MILLISECONDS);
|
|
}
|
|
|
|
private void sendAllValid(final ChannelHandlerContext ctx, final long now) {
|
|
// write order control
|
|
synchronized (this) {
|
|
ToSend newToSend = messagesQueue.pollFirst();
|
|
for (; newToSend != null; newToSend = messagesQueue.pollFirst()) {
|
|
if (newToSend.relativeTimeAction <= now) {
|
|
long size = calculateSize(newToSend.toSend);
|
|
trafficCounter.bytesRealWriteFlowControl(size);
|
|
queueSize -= size;
|
|
ctx.write(newToSend.toSend, newToSend.promise);
|
|
} else {
|
|
messagesQueue.addFirst(newToSend);
|
|
break;
|
|
}
|
|
}
|
|
if (messagesQueue.isEmpty()) {
|
|
releaseWriteSuspended(ctx);
|
|
}
|
|
}
|
|
ctx.flush();
|
|
}
|
|
|
|
/**
|
|
* @return current size in bytes of the write buffer.
|
|
*/
|
|
public long queueSize() {
|
|
return queueSize;
|
|
}
|
|
}
|