[JAVA]流控及超流控后的延迟处理

流控检查（每半秒累计，因此最小留空阀值只能做到每秒2条）：

import java.text.SimpleDateFormat;

import java.util.Date;

import java.lang.Thread;



/**

 * 流量控制

 * 

 * @author chenx

 */

public class OverflowController {



	private int maxSendCountPerSecend; // 该条链路上流控阀值

	private Date sendTime = new Date();

	private int sendCount = 0; // 该条链路上发送的数量



	public OverflowController(int maxSendCountPerSecend) {

		if (maxSendCountPerSecend < 2) {

			maxSendCountPerSecend = 2;

		}



		this.maxSendCountPerSecend = maxSendCountPerSecend;

	}



	public int getMaxSendCountPerSecend() {

		if (getMilliseconds(new Date()) >= 500) {

			return maxSendCountPerSecend / 2;

		}



		return maxSendCountPerSecend - (maxSendCountPerSecend / 2);

	}



	/**

	 * 是否超流控

	 */

	public boolean isOverflow(int sendNum) {

		synchronized (this) {

			Date now = new Date();

			if (now.getTime() - sendTime.getTime() >= 500) {

				sendTime = now;

				sendCount = sendNum;

			} else {

				if (sendCount + sendNum > getMaxSendCountPerSecend()) {

					return true;

				} else {

					sendCount += sendNum;

				}

			}



			return false;

		}

	}



	/**

	 * 获取指定时间的毫秒数

	 */

	private int getMilliseconds(Date date) {

		SimpleDateFormat df = new SimpleDateFormat("SSS");

		return Integer.valueOf(df.format(date));

	}



	public static void main(String[] args) throws InterruptedException {

		OverflowController oc = new OverflowController(50);

		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");

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

			if (oc.isOverflow(1)) {

				System.out.println(i + "-isOverflow-" + df.format(new Date()));

			} else {

				System.out.println(i + "-sendOk-" + df.format(new Date()));

			}



			Thread.sleep(10);

		}

	}

}

超流控后的延迟处理，由于java中没有.net的“延迟委托”一说：

ThreadPool.RegisterWaitForSingleObject(
 WaitHandle waitObject,
      WaitOrTimerCallback callBack,
      Object state,
     int millisecondsTimeOutInterval,
     bool executeOnlyOnce

)

Java下需实现一个简单的延迟队列：

import java.util.concurrent.Delayed;

import java.util.concurrent.TimeUnit;



public class DelayEntry implements Delayed {



	private int count;

	private long dequeuedTimeMillis; // 出队列时间



	public int getCount() {

		return count;

	}



	public void setCount(int count) {

		this.count = count;

	}



	public long getDequeuedTimeMillis() {

		return dequeuedTimeMillis;

	}



	public DelayEntry(long delayMillis) {

		dequeuedTimeMillis = System.currentTimeMillis() + delayMillis;

	}



	@Override

	public int compareTo(Delayed o) {

		DelayEntry de = (DelayEntry) o;

		long timeout = dequeuedTimeMillis - de.dequeuedTimeMillis;

		return timeout > 0 ? 1 : timeout < 0 ? -1 : 0;

	}



	@Override

	public long getDelay(TimeUnit unit) {

		return dequeuedTimeMillis - System.currentTimeMillis();

	}

}

 

import java.util.concurrent.DelayQueue;



public class DelayService {



	public void run() {

		DelayQueue<DelayEntry> queue = new DelayQueue<DelayEntry>();

		DelayConsumer delayConsumer = new DelayConsumer(queue);

		delayConsumer.start();



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

			DelayEntry de = new DelayEntry(5000);

			de.setCount(i);

			System.out.println(System.currentTimeMillis() + "--------" + de.getCount());

			queue.add(de);

		}

	}



	class DelayConsumer extends Thread {

		DelayQueue<DelayEntry> queue;

		public DelayConsumer(DelayQueue<DelayEntry> queue) {

			this.queue = queue;

		}



		public void run() {

			while (true) {

				try {

					DelayEntry de = queue.take();

					System.out.println("queue size=" + queue.size());

					System.out.println(de.getCount());

					System.out.println(System.currentTimeMillis());

				} catch (InterruptedException e) {

					e.printStackTrace();

				}

			}

		}

	}



	public static void main(String[] args) {

		DelayService ds = new DelayService();

		ds.run();

	}

}