Question

刷新数据库中的记录。我们要么获得明确的刷新通知，要么每60秒轮询一次。每秒不超过一次刷新。

如果请求进来，如果在一秒钟内没有发生请求，则应立即刷新。否则，它应该在最后一次刷新结束后安排刷新1秒，除非这样的任务已经安排在那个时间或更早。

在没有明确刷新的情况下一分钟后，如果没有发送通知，计时器应该启动并刷新。

可能会有大量通知（每秒数百个）。

刷新可以通过单独的单个线程完成。

设计这个的优雅方法是什么？

这里有我所拥有的，但可能会导致太多请求：

private NotificationCenter() {
    recordFetchService = Executors.newSingleThreadScheduledExecutor();
    recordFetchService.scheduleWithFixedDelay(refreshCommand, minTimeBetweenRefresh, maxTimeBetweenRefresh, TimeUnit.MILLISECONDS);
}

private void queueRefresh() {
    // explicit refresh requested. Schedule a refreshCommand to fire immediately, unless that would break our contract
    if (!pending.isDone() && pending.getDelay(TimeUnit.MILLISECONDS) < minTimeBetweenRefresh) {
        // a refresh is already scheduled
    } else {
        pending = recordFetchService.schedule(refreshCommand, 0L, TimeUnit.MILLISECONDS);
    }
}

Answer 1

＆＃34;每秒数百个通知＆＃34;我想到一个AtomicBoolean来完全切换状态一次＆＃34;什么都不做＆＃34;去做某事＆＃34;去做某事＆＃34;反之亦然。结合＆＃34;做某事＆＃34;状态为Semaphore，您可以选择确定＆＃34;做某事的确切时刻＆＃34;发生了。

在（runnable）示例实现/设计下面，它结合AtomicBoolean和Semaphore来定期刷新数据，同时使用通知。它可能不是最优雅的方式，但我认为它以相对简单的方式完成了目标。

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;

public class RefreshTask {

    private static final long MIN_WAIT_MS = 100L;
    private static final long MAX_WAIT_MS = 1000L;

    private ScheduledExecutorService scheduler;
    private ExecutorService executor;
    private volatile boolean stopping; 

    private final Semaphore refreshLock = new Semaphore(0);
    private final AtomicBoolean refreshing = new AtomicBoolean();
    private volatile long lastRefresh;

    public void start() {

        stopping = false;
        refreshing.set(true);
        lastRefresh = System.currentTimeMillis();
        executor = Executors.newSingleThreadExecutor();
        executor.execute(new RefreshLoop());
        scheduler = Executors.newSingleThreadScheduledExecutor();
    }

    public void stop() {

        stopping = true;
        if (executor != null) {
            refreshLock.release();
            scheduler.shutdownNow();
            executor.shutdownNow();
        }
    }

    /** Trigger a (scheduled) refresh of data. */
    public void refresh() {

        if (refreshing.compareAndSet(false, true)) {
            final long dataAge = System.currentTimeMillis() - lastRefresh;
            if (dataAge >= MIN_WAIT_MS) {
                refreshLock.release();
                // println("Refresh lock released.");
            } else {
                long waitTime = MIN_WAIT_MS - dataAge;
                scheduler.schedule(new RefreshReleaser(), waitTime, TimeUnit.MILLISECONDS);
                println("Refresh scheduled in " + waitTime + " ms.");
            }
        } else {
            // println("Refresh already triggered.");
        }
    }

    protected void refreshData() {

        // Refresh data from database
        println("DATA refresh");
    }

    class RefreshLoop implements Runnable {

        @Override
        public void run() {

            while (!stopping) {
                try {
                    refreshData();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                lastRefresh = System.currentTimeMillis();
                refreshing.set(false);
                try {
                    if (!refreshLock.tryAcquire(MAX_WAIT_MS, TimeUnit.MILLISECONDS)) {
                        if (!refreshing.compareAndSet(false, true)) {
                            // Unlikely state, but can happen if "dataAge" in the refresh-method is around MAX_WAIT_MS.
                            // Resolve the race-condition by removing the extra permit.
                            if (refreshLock.tryAcquire()) {
                                println("Refresh lock race-condition detected, removed additional permit.");
                            } else {
                                println("Refresh lock race-condition detected, but no additional permit found.");
                            }
                        }
                        println("Refreshing after max waiting time.");
                    } // else refreshing already set to true
                } catch (InterruptedException ie) {
                    if (!stopping) {
                        ie.printStackTrace();
                    }
                }
            }
            println("Refresh loop stopped.");
        }
    }

    class RefreshReleaser implements Runnable {

        @Override
        public void run() {

            if (refreshing.get()) {
                refreshLock.release();
                println("Scheduled refresh lock release.");
            } else {
                println("Programming error, scheduled refresh lock release can only be done in refreshing state.");
            }
        }
    }

    /* *** some testing *** */

    public static void main(String[] args) {

        RefreshTask rt = new RefreshTask();
        try {
            println("Starting");
            rt.start();
            Thread.sleep(2 * MIN_WAIT_MS);
            println("Triggering refresh");
            rt.refresh();
            Thread.sleep(MAX_WAIT_MS + (MIN_WAIT_MS / 2));
            println("Triggering refresh 2");
            rt.refresh();
            Thread.sleep(MIN_WAIT_MS);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rt.stop();
        }
    }

    public static final long startTime = System.currentTimeMillis();

    public static void println(String msg) {
        println(System.currentTimeMillis() - startTime, msg);
    }

    public static void println(long tstamp, String msg) {
        System.out.println(String.format("%05d ", tstamp) + msg);
    }

}

在任务之间调度具有最大/最小持续时间的任务

1 个答案: