Contoh penundaan pemrosesan setelah kontrol aliran JAVA dan kontrol aliran super

Artikel ini menjelaskan metode pemrosesan penundaan setelah kontrol aliran JAVA dan kontrol aliran super. Bagikan dengan semua orang untuk referensi Anda. Metode implementasi spesifiknya adalah sebagai berikut:

Pemeriksaan kontrol aliran (diakumulasi setiap setengah detik, sehingga ambang kosong minimum hanya boleh 2 item per detik):

Salin kode sebagai berikut: import java.text.SimpleDateFormat;
import java.util.Date;
impor java.lang.Thread;

/**
* Kontrol aliran
*
* @penulis chenx
*/
kelas publik OverflowController {

private int maxSendCountPerSecend; // Batas kendali aliran pada tautan ini
Tanggal pribadi sendTime = Tanggal baru();
private int sendCount = 0; //Nomor yang dikirim pada tautan ini

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

this.maxSendCountPerSecend = maxSendCountPerSecend;
}

publik int getMaxSendCountPerSecend() {
if (getMilliseconds(Tanggal baru()) >= 500) {
kembalikan maxSendCountPerSecend / 2;
}

kembalikan maxSendCountPerSecend - (maxSendCountPerSecend / 2);
}

/**
* Apakah itu kontrol aliran super
*/
boolean publik isOverflow(int sendNum) {
disinkronkan (ini) {
Tanggal sekarang = Tanggal baru();
if (sekarang.getTime() - sendTime.getTime() >= 500) {
sendTime = sekarang;
sendCount = sendNum;
} kalau tidak {
jika (sendCount + sendNum > getMaxSendCountPerSecend()) {
kembali benar;
} kalau tidak {
sendCount += sendNum;
}
}

kembali salah;
}
}

/**
* Dapatkan jumlah milidetik dalam waktu yang ditentukan
*/
private int getMilliseconds(Tanggal tanggal) {
SimpleDateFormat df = new SimpleDateFormat("SSS");
return Integer.valueOf(df.format(tanggal));
}

public static void main(String[] args) melempar InterruptedException {
OverflowController oc = OverflowController baru(50);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
untuk (int saya = 0; saya <= 100; saya++) {
jika (oc.isOverflow(1)) {
System.out.println(i + "-isOverflow-" + df.format(Tanggal baru()));
} kalau tidak {
System.out.println(i + "-sendOk-" + df.format(Tanggal baru()));
}

Thread.tidur(10);
}
}
}
Tunda pemrosesan setelah kontrol aliran super, karena tidak ada "delegasi penundaan" .net di Java:
Salin kode sebagai berikut: ThreadPool.RegisterWaitForSingleObject(
TungguHandle tungguObjek,
Panggilan Balik WaitOrTimerCallback,
Keadaan objek,
int milidetikTimeOutInterval,
bool mengeksekusiHanya Sekali
)

Antrian penundaan sederhana perlu diterapkan di Java:

Salin kode sebagai berikut: import java.util.concurrent.Delayed;
import java.util.bersamaan.TimeUnit;

kelas publik DelayEntry mengimplementasikan Tertunda {

jumlah int pribadi;
private long dequeuedTimeMillis; // waktu dequeue

publik int getCount() {
jumlah pengembalian;
}

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

publik panjang getDequeuedTimeMillis() {
kembalikan dequeuedTimeMillis;
}

public DelayEntry(penundaan lamaMillis) {
dequeuedTimeMillis = Sistem.currentTimeMillis() + delayMillis;
}

@Mengesampingkan
public int bandingkanTo(Tertunda o) {
DelayEntry de = (DelayEntry) o;
batas waktu lama = dequeuedTimeMillis - de.dequeuedTimeMillis;
batas waktu kembali > 0 ? 1 : batas waktu < 0 ?
}

@Mengesampingkan
public long getDelay(Satuan Waktu) {
kembalikan dequeuedTimeMillis - System.currentTimeMillis();
}
}

Salin kode sebagai berikut: import java.util.concurrent.DelayQueue;

Layanan Penundaan kelas publik {

menjalankan kekosongan publik() {
DelayQueue<DelayEntry> antrian = DelayQueue<DelayEntry>();
DelayConsumer delayConsumer = new DelayConsumer(antrian);
delayConsumer.mulai();

untuk (int saya = 0; saya < 100; saya++) {
DelayEntry de = DelayEntry baru(5000);
de.setCount(i);
System.out.println(System.currentTimeMillis() + "--------" + de.getCount());
antrian.tambahkan(de);
}
}

kelas DelayConsumer memperluas Thread {
DelayQueue<DelayEntry> antrian;
public DelayConsumer(delayQueue<DelayEntry> antrian) {
this.queue = antrian;
}

menjalankan kekosongan publik() {
sementara (benar) {
mencoba {
DelayEntry de = antrian.take();
System.out.println("ukuran antrian=" + antrian.ukuran());
Sistem.keluar.println(de.getCount());
System.out.println(System.currentTimeMillis());
} tangkapan (InterruptedException e) {
e.printStackTrace();
}
}
}
}

public static void main(String[] args) {
DelayService ds = new DelayService();
ds.menjalankan();
}
}

Saya harap artikel ini bermanfaat untuk pemrograman Java semua orang.