JAVA 操作防抖（非RxJava方案）

JAVA 操作防抖，在手机网络状态变化时发生了重复调用，因此需要进行防抖。

本打算用RxJava方案的，发现没必要那么麻烦，就找了个现成的类修改了下，发现确实还比较好用，代码如下。

package com.xxx.xxx;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 操作防抖
 * @param  参数类型
 */
public class Debouncer {
    private final ScheduledExecutorService sched = Executors.newScheduledThreadPool(1);
    private final ConcurrentHashMap delayedMap = new ConcurrentHashMap();
    private final Callback callback;
    private final int interval;

    public interface Callback {
        void call(T param);
    }

    public Debouncer(Callback c, int interval) {
        this.callback = c;
        this.interval = interval;
    }

    public void call(T param) {
        TimerTask task = new TimerTask(param);

        TimerTask prev;
        do {
            prev = delayedMap.putIfAbsent(param, 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 param;
        private long dueTime;
        private final Object lock = new Object();

        public TimerTask(T param) {
            this.param = param;
            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(param);
                    } finally {
                        delayedMap.remove(param);
                    }
                }
            }
        }
    }
}

调用：

    private Debouncer debouncer = new Debouncer(new Debouncer.Callback(){
        @Override
        public void call(String param) {
            System.out.println("call with param:" + param);
        }
    }, 500);

debouncer.call("参数A");