thực hiện debounce trong Java

Question

Đối với một số mã tôi đang viết tôi có thể sử dụng một thực hiện chung tốt đẹp của debounce trong Java.

public interface Callback { 
    public void call(Object arg); 
} 

class Debouncer implements Callback { 
    public Debouncer(Callback c, int interval) { ... } 

    public void call(Object arg) { 
     // should forward calls with the same arguments to the callback c 
     // but batch multiple calls inside `interval` to a single one 
    } 
} 

Khi call() được gọi nhiều lần trong interval mili giây với lập luận tương tự chức năng gọi lại nên được gọi là đúng một lần.

Một hình dung:

Debouncer#call xxx x xxxxxxx  xxxxxxxxxxxxxxx 
Callback#call  x   x      x (interval is 2) 

• Liệu (một cái gì đó tương tự) tồn tại này đã có trong một số thư viện chuẩn Java?
• Bạn sẽ triển khai điều đó như thế nào?

Answer 1

Hãy xem xét các giải pháp đề an toàn sau đây. Lưu ý rằng độ chi tiết khóa ở cấp độ khóa, do đó chỉ có các cuộc gọi trên cùng một khối khóa. Nó cũng xử lý trường hợp hết hạn trên khóa K xảy ra trong khi gọi (K) được gọi.

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); 
      } 
     } 
     } 
    } 
    } 

Answer 2

Tôi không biết nó có tồn tại hay không nhưng cần phải thực hiện đơn giản.

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); 
     } 
    } 
} 

Tất nhiên ví dụ này đơn giản hóa nó một chút, nhưng điều này ít nhiều là bạn cần. Nếu bạn muốn giữ thời gian chờ riêng biệt cho các đối số khác nhau, bạn sẽ cần một Map<Object,long> thay vì chỉ một long để theo dõi thời gian thực hiện cuối cùng.

Answer 3

này có vẻ như nó có thể làm việc:

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); 
    } 
} 

Answer 4

Triển khai sau đây hoạt động trên các chuỗi dựa trên trình xử lý (ví dụ: chuỗi giao diện người dùng chính hoặc trong IntentService). Nó hy vọng chỉ được gọi từ thread mà nó được tạo ra, và nó cũng sẽ chạy nó trên action này.

public class Debouncer 
{ 
    private CountDownTimer debounceTimer; 
    private Runnable pendingRunnable; 

    public Debouncer() { 

    } 

    public void debounce(Runnable runnable, long delayMs) { 
     pendingRunnable = runnable; 
     cancelTimer(); 
     startTimer(delayMs); 
    } 

    public void cancel() { 
     cancelTimer(); 
     pendingRunnable = null; 
    } 

    private void startTimer(final long updateIntervalMs) { 

     if (updateIntervalMs > 0) { 

      // Debounce timer 
      debounceTimer = new CountDownTimer(updateIntervalMs, updateIntervalMs) { 

       @Override 
       public void onTick(long millisUntilFinished) { 
        // Do nothing 
       } 

       @Override 
       public void onFinish() { 
        execute(); 
       } 
      }; 
      debounceTimer.start(); 
     } 
     else { 

      // Do immediately 
      execute(); 
     } 
    } 

    private void cancelTimer() { 
     if (debounceTimer != null) { 
      debounceTimer.cancel(); 
      debounceTimer = null; 
     } 
    } 

    private void execute() { 
     if (pendingRunnable != null) { 
      pendingRunnable.run(); 
      pendingRunnable = null; 
     } 
    } 
} 

Answer 5

Dưới đây là thực hiện của tôi:

public class Debouncer { 
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); 
    private final ConcurrentHashMap<Object, Future<?>> delayedMap = new ConcurrentHashMap<>(); 

    /** 
    * Debounces {@code callable} by {@code delay}, i.e., schedules it to be executed after {@code delay}, 
    * or cancels its execution if the method is called with the same key within the {@code delay} again. 
    */ 
    public void debounce(final Object key, final Runnable runnable, long delay, TimeUnit unit) { 
     final Future<?> prev = delayedMap.put(key, scheduler.schedule(new Runnable() { 
      @Override 
      public void run() { 
       try { 
        runnable.run(); 
       } finally { 
        delayedMap.remove(key); 
       } 
      } 
     }, delay, unit)); 
     if (prev != null) { 
      prev.cancel(true); 
     } 
    } 

    public void shutdown() { 
     scheduler.shutdownNow(); 
    } 
} 

Ví dụ sử dụng:

final Debouncer debouncer = new Debouncer(); 
debouncer.debounce(Void.class, new Runnable() { 
    @Override public void run() { 
     // ... 
    } 
}, 300, TimeUnit.MILLISECONDS);