Exemples de traitement de retard après le contrôle de flux JAVA et le contrôle de super flux

Cet article décrit la méthode de traitement des retards après le contrôle de flux JAVA et le contrôle de super flux. Partagez-le avec tout le monde pour votre référence. La méthode spécifique de mise en œuvre est la suivante :

Vérification du contrôle de flux (accumulé toutes les demi-secondes, de sorte que le seuil de blanc minimum ne peut être que de 2 éléments par seconde) :

Copiez le code comme suit : import java.text.SimpleDateFormat ;
importer java.util.Date ;
importer java.lang.Thread ;

/**
* Contrôle de flux
*
* @auteur chenx
*/
classe publique OverflowController {

private int maxSendCountPerSecend; // Seuil de contrôle de flux sur ce lien
date privée sendTime = new Date();
private int sendCount = 0; //Le numéro envoyé sur ce lien

public OverflowController (int maxSendCountPerSecend) {
si (maxSendCountPerSecend < 2) {
maxSendCountPerSecend = 2 ;
}

this.maxSendCountPerSecend = maxSendCountPerSecend ;
}

public int getMaxSendCountPerSecend() {
if (getMilliseconds(new Date()) >= 500) {
renvoyer maxSendCountPerSecend / 2 ;
}

return maxSendCountPerSecend - (maxSendCountPerSecend / 2);
}

/**
* Qu'il s'agisse d'un super contrôle de flux
*/
public booléen isOverflow (int sendNum) {
synchronisé (ce) {
Date maintenant = nouvelle Date();
if (maintenant.getTime() - sendTime.getTime() >= 500) {
sendTime = maintenant ;
sendCount = sendNum ;
} autre {
if (sendCount + sendNum > getMaxSendCountPerSecend()) {
renvoie vrai ;
} autre {
sendCount += sendNum ;
}
}

renvoie faux ;
}
}

/**
* Obtenez le nombre de millisecondes dans le temps spécifié
*/
private int getMilliseconds(Date date) {
SimpleDateFormat df = new SimpleDateFormat("SSS");
return Integer.valueOf(df.format(date));
}

public static void main (String[] args) lance InterruptedException {
OverflowController oc = nouveau OverflowController(50);
SimpleDateFormat df = new SimpleDateFormat("aaaa-MM-jj HH:mm:ss:SSS");
pour (int je = 0; je <= 100; i++) {
si (oc.isOverflow(1)) {
System.out.println(i + "-isOverflow-" + df.format(new Date()));
} autre {
System.out.println(i + "-sendOk-" + df.format(new Date()));
}

Thread.sleep(10);
}
}
}
Retarder le traitement après le super contrôle de flux, car il n'y a pas de "délégation de retard" de .net en Java :
Copiez le code comme suit : ThreadPool.RegisterWaitForSingleObject(
WaitHandle waitObject,
WaitOrTimerCallback rappel,
État de l'objet,
int millisecondesTimeOutInterval,
bool exécuterOnlyOnce
)

Une simple file d'attente doit être implémentée en Java :

Copiez le code comme suit : import java.util.concurrent.Delayed ;
importer java.util.concurrent.TimeUnit ;

la classe publique DelayEntry implémente Delayed {

nombre d'ints privés ;
private long dequeuedTimeMillis ; // temps de sortie de la file d'attente

public int getCount() {
nombre de retours ;
}

public void setCount (int compte) {
this.count = nombre ;
}

public long getDequeuedTimeMillis() {
retourner dequeuedTimeMillis ;
}

public DelayEntry (long delayMillis) {
dequeuedTimeMillis = System.currentTimeMillis() + delayMillis ;
}

@Outrepasser
public int compareTo (o retardé) {
DelayEntry de = (DelayEntry) o;
long délai d'attente = dequeuedTimeMillis - de.dequeuedTimeMillis ;
retour délai d'attente > 0 ? 1 : délai d'attente < 0 -1 : 0;
}

@Outrepasser
public long getDelay (unité TimeUnit) {
return dequeuedTimeMillis - System.currentTimeMillis();
}
}

Copiez le code comme suit : import java.util.concurrent.DelayQueue ;

classe publique DelayService {

public void run() {
DelayQueue<DelayEntry> queue = new DelayQueue<DelayEntry>();
DelayConsumer delayConsumer = new DelayConsumer (file d'attente);
delayConsumer.start();

pour (int je = 0; je < 100; i++) {
DelayEntry de = nouveau DelayEntry (5000);
de.setCount(i);
System.out.println(System.currentTimeMillis() + "--------" + de.getCount());
queue.add(de);
}
}

la classe DelayConsumer étend le fil {
File d'attente DelayQueue<DelayEntry> ;
public DelayConsumer (file d'attente DelayQueue<DelayEntry>) {
this.queue = file d'attente ;
}

public void run() {
tandis que (vrai) {
essayer {
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[] arguments) {
DelayService ds = new DelayService();
ds.run();
}
}

J'espère que cet article sera utile à la programmation Java de chacun.