+++ /dev/null
-/*
- * Copyright (c) 2011,2013 Big Switch Networks, Inc.
- *
- * Licensed under the Eclipse Public License, Version 1.0 (the
- * "License"); you may not use this file except in compliance with the
- * License. You may obtain a copy of the License at
- *
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- *
- * This file incorporates work covered by the following copyright and
- * permission notice:
- *
- * Originally created by David Erickson, Stanford University
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the
- * License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS
- * IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
- * express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-package org.opendaylight.controller.sal.utils;
-
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * This allows you to represent a task that should be queued for future
- * execution but where you only want the task to complete once in response to
- * some sequence of events. For example, if you get a change notification and
- * want to reload state, you only want to reload the state once, at the end, and
- * don't want to queue an update for every notification that might come in.
- *
- * The semantics are as follows: * If the task hasn't begun yet, do not queue a
- * new task * If the task has begun, set a bit to restart it after the current
- * task finishes
- */
-public class SingletonTask {
- protected static Logger logger = LoggerFactory
- .getLogger(SingletonTask.class);
-
- protected static class SingletonTaskContext {
- protected boolean taskShouldRun = false;
- protected boolean taskRunning = false;
-
- protected SingletonTaskWorker waitingTask = null;
- }
-
- protected static class SingletonTaskWorker implements Runnable {
- SingletonTask parent;
- boolean canceled = false;
- long nextschedule = 0;
-
- public SingletonTaskWorker(SingletonTask parent) {
- super();
- this.parent = parent;
- }
-
- @Override
- public void run() {
- synchronized (parent.context) {
- if (canceled || !parent.context.taskShouldRun)
- return;
-
- parent.context.taskRunning = true;
- parent.context.taskShouldRun = false;
- }
-
- try {
- parent.task.run();
- } catch (Exception e) {
- logger.error("Exception while executing task", e);
- }
-
- synchronized (parent.context) {
- parent.context.taskRunning = false;
-
- if (parent.context.taskShouldRun) {
- long now = System.nanoTime();
- if ((nextschedule <= 0 || (nextschedule - now) <= 0)) {
- parent.ses.execute(this);
- } else {
- parent.ses.schedule(this, nextschedule - now,
- TimeUnit.NANOSECONDS);
- }
- }
- }
- }
- }
-
- protected SingletonTaskContext context = new SingletonTaskContext();
- protected Runnable task;
- protected ScheduledExecutorService ses;
-
- /**
- * Construct a new SingletonTask for the given runnable. The context is used
- * to manage the state of the task execution and can be shared by more than
- * one instance of the runnable.
- *
- * @param context
- * @param Task
- */
- public SingletonTask(ScheduledExecutorService ses, Runnable task) {
- super();
- this.task = task;
- this.ses = ses;
- }
-
- /**
- * Schedule the task to run if there's not already a task scheduled If there
- * is such a task waiting that has not already started, it cancel that task
- * and reschedule it to run at the given time. If the task is already
- * started, it will cause the task to be rescheduled once it completes to
- * run after delay from the time of reschedule.
- *
- * @param delay
- * the delay in scheduling
- * @param unit
- * the timeunit of the delay
- */
- public void reschedule(long delay, TimeUnit unit) {
- boolean needQueue = true;
- SingletonTaskWorker stw = null;
-
- synchronized (context) {
- if (context.taskRunning || context.taskShouldRun) {
- if (context.taskRunning) {
- // schedule to restart at the right time
- if (delay > 0) {
- long now = System.nanoTime();
- long then = now
- + TimeUnit.NANOSECONDS.convert(delay, unit);
- context.waitingTask.nextschedule = then;
- } else {
- context.waitingTask.nextschedule = 0;
- }
- needQueue = false;
- } else {
- // cancel and requeue
- context.waitingTask.canceled = true;
- context.waitingTask = null;
- }
- }
-
- context.taskShouldRun = true;
-
- if (needQueue) {
- stw = context.waitingTask = new SingletonTaskWorker(this);
- }
- }
-
- if (needQueue) {
- if (delay <= 0) {
- ses.execute(stw);
- }
- else {
- ses.schedule(stw, delay, unit);
- }
- }
- }
-}
\ No newline at end of file
Code Review / controller.git / blobdiff