Ejemplos de procesamiento de retraso después del control de flujo JAVA y el control de superflujo

Este artículo describe el método de procesamiento de retraso después del control de flujo JAVA y el control de superflujo. Compártelo con todos para tu referencia. El método de implementación específico es el siguiente:

Verificación de control de flujo (acumulada cada medio segundo, por lo que el umbral mínimo en blanco solo puede ser 2 elementos por segundo):

Copie el código de la siguiente manera: import java.text.SimpleDateFormat;
importar java.util.Fecha;
importar java.lang.Thread;

/**
* Control de flujo
*
*@autor chenx
*/
clase pública OverflowController {

private int maxSendCountPerSecend // Umbral de control de flujo en este enlace
fecha privada sendTime = nueva fecha();
private int sendCount = 0; //El número enviado en este enlace

público OverflowController (int maxSendCountPerSecend) {
si (maxSendCountPerSecend < 2) {
maxSendCountPerSecend = 2;
}

this.maxSendCountPerSecend = maxSendCountPerSecend;
}

público int getMaxSendCountPerSecend() {
if (getMillisegundos(nueva fecha()) >= 500) {
devolver maxSendCountPerSecend / 2;
}

devolver maxSendCountPerSecend - (maxSendCountPerSecend / 2);
}

/**
* Si se trata de control de superflujo
*/
público booleano isOverflow(int sendNum) {
sincronizado (esto) {
Fecha ahora = nueva fecha();
if (ahora.getTime() - sendTime.getTime() >= 500) {
enviarHora = ahora;
enviarCuenta = enviarNúm;
} demás {
if (enviarCuenta + enviarNúm > getMaxSendCountPerSecend()) {
devolver verdadero;
} demás {
enviarCount += enviarNum;
}
}

devolver falso;
}
}

/**
* Obtener el número de milisegundos en el tiempo especificado
*/
privado int getMillisegundos(Fecha fecha) {
SimpleDateFormat df = nuevo SimpleDateFormat("SSS");
return Integer.valueOf(df.format(fecha));
}

public static void main (String [] args) lanza InterruptedException {
OverflowController oc = nuevo OverflowController(50);
SimpleDateFormat df = new SimpleDateFormat("aaaa-MM-dd HH:mm:ss:SSS");
para (int i = 0; i <= 100; i++) {
si (oc.isOverflow(1)) {
System.out.println(i + "-isOverflow-" + df.format(nueva fecha()));
} demás {
System.out.println(i + "-sendOk-" + df.format(nueva fecha()));
}

Hilo.dormir(10);
}
}
}
Retrasar el procesamiento después del control de superflujo, porque no existe una "delegación de retraso" de .net en Java:
Copie el código de la siguiente manera: ThreadPool.RegisterWaitForSingleObject(
WaitHandle esperarObjeto,
WaitOrTimerCallback callBack,
estado del objeto,
int milisegundosTimeOutInterval,
bool ejecutar solo una vez
)

Es necesario implementar una cola de retraso simple en Java:

Copie el código de la siguiente manera: import java.util.concurrent.Delayed;
importar java.util.concurrent.TimeUnit;

la clase pública DelayEntry implementa Delayed {

recuento de int privado;
private long dequeuedTimeMillis // tiempo de salida de cola

público int getCount() {
recuento de devoluciones;
}

setCount vacío público (int recuento) {
this.count = contar;
}

público largo getDequeuedTimeMillis() {
devolver TimeMillis fuera de la cola;
}

entrada de retardo pública (retraso largoMillis) {
dequeuedTimeMillis = System.currentTimeMillis() + delayMillis;
}

@Anular
public int compareTo(Retrasado o) {
EntradaDelay de = (EntradaDelay) o;
tiempo de espera prolongado = dequeuedTimeMillis - de.dequeuedTimeMillis;
tiempo de espera de retorno> 0? 1: tiempo de espera <0?
}

@Anular
getDelay largo público (unidad TimeUnit) {
return dequeuedTimeMillis - System.currentTimeMillis();
}
}

Copie el código de la siguiente manera: import java.util.concurrent.DelayQueue;

clase pública DelayService {

ejecución pública vacía() {
Cola DelayQueue<DelayEntry> = nueva DelayQueue<DelayEntry>();
DelayConsumer delayConsumer = new DelayConsumer(cola);
retrasoConsumidor.start();

para (int i = 0; i < 100; i++) {
DelayEntry de = new DelayEntry(5000);
de.setCount(i);
System.out.println(System.currentTimeMillis() + "--------" + de.getCount());
cola.add(de);
}
}

clase DelayConsumer extiende Thread {
Cola DelayQueue<DelayEntry>;
público DelayConsumer (cola DelayQueue <DelayEntry>) {
this.queue = cola;
}

ejecución pública vacía() {
mientras (verdadero) {
intentar {
DelayEntry de = queue.take();
System.out.println("tamaño de cola=" + cola.tamaño());
System.out.println(de.getCount());
System.out.println(System.currentTimeMillis());
} captura (Excepción interrumpida e) {
e.printStackTrace();
}
}
}
}

público estático vacío principal (String [] argumentos) {
DelayService ds = nuevo DelayService();
ds.run();
}
}

Espero que este artículo sea útil para la programación Java de todos.