la mise en œuvre de antirebond en Java

Veuillez considérer ce qui suit thread-safe solution. Notez que la serrure de la granularité est sur le niveau principal, de sorte que seuls les appels sur la même touche de bloquer les uns les autres. Il gère également le cas d'une date d'expiration sur la touche K, qui se produit pendant l'appel(K) est appelée.

public class Debouncer <T> {
private final ScheduledExecutorService sched = Executors.newScheduledThreadPool(1);
private final ConcurrentHashMap<T, TimerTask> delayedMap = new ConcurrentHashMap<T, TimerTask>();
private final Callback<T> callback;
private final int interval;
public Debouncer(Callback<T> c, int interval) { 
this.callback = c;
this.interval = interval;
}
public void call(T key) {
TimerTask task = new TimerTask(key);
TimerTask prev;
do {
prev = delayedMap.putIfAbsent(key, task);
if (prev == null)
sched.schedule(task, interval, TimeUnit.MILLISECONDS);
} while (prev != null && !prev.extend()); //Exit only if new task was added to map, or existing task was extended successfully
}
public void terminate() {
sched.shutdownNow();
}
//The task that wakes up when the wait time elapses
private class TimerTask implements Runnable {
private final T key;
private long dueTime;    
private final Object lock = new Object();
public TimerTask(T key) {        
this.key = key;
extend();
}
public boolean extend() {
synchronized (lock) {
if (dueTime < 0) //Task has been shutdown
return false;
dueTime = System.currentTimeMillis() + interval;
return true;
}
}
public void run() {
synchronized (lock) {
long remaining = dueTime - System.currentTimeMillis();
if (remaining > 0) { //Re-schedule task
sched.schedule(this, remaining, TimeUnit.MILLISECONDS);
} else { //Mark as terminated and invoke callback
dueTime = -1;
try {
callback.call(key);
} finally {
delayedMap.remove(key);
}
}
}
}  
}

Je ne sais pas si cela existe mais il doit être simple à mettre en œuvre.

class Debouncer implements Callback {
private CallBack c;
private volatile long lastCalled;
private int interval;
public Debouncer(Callback c, int interval) {
//init fields
}
public void call(Object arg) { 
if( lastCalled + interval < System.currentTimeMillis() ) {
lastCalled = System.currentTimeMillis();
c.call( arg );
} 
}
}

Bien entendu, cet exemple simplifie outre mesure un peu, mais c'est plus ou moins tout ce que vous devez. Si vous souhaitez conserver à l'écart délais d'attente pour les différents arguments, vous aurez besoin d'un Map<Object,long> au lieu de seulement un long de garder une trace de la dernière moment de l'exécution.

Cela ressemble à cela pourrait fonctionner:

class Debouncer implements Callback {
private Callback callback;
private Map<Integer, Timer> scheduled = new HashMap<Integer, Timer>();
private int delay;
public Debouncer(Callback c, int delay) {
this.callback = c;
this.delay = delay;
}
public void call(final Object arg) {
final int h = arg.hashCode();
Timer task = scheduled.remove(h);
if (task != null) { task.cancel(); }
task = new Timer();
scheduled.put(h, task);
task.schedule(new TimerTask() {
@Override
public void run() {
callback.call(arg);
scheduled.remove(h);
}
}, this.delay);
}
}