/** Removes the task. */ public void remove() { startTask.cancel(); endTask.cancel(); calendarService.removeFromTaskMap(id); calendarService.removeFromCurrentItems(this); calendarService.updateStateFromCurrentItems(); }
void checkUserClockChange() { if (!hasUserClockTasks()) { return; } final long userClockSkew = Timer.userClockSkew(); if (userClockSkew == 0) { return; } if (userClockSkew < 0) { for (int i = 1; i <= size; i++) { TimerTask task = queue[i]; if (task != null && task.isUserClock) { task.nextExecutionTime -= userClockSkew; fixUp(i); } } } else { for (int i = size; i >= 1; i--) { TimerTask task = queue[i]; if (task != null && task.isUserClock) { task.nextExecutionTime -= userClockSkew; fixDown(i); } } } }
private void resetClientTimer(Socket socket) { if (this.idleClientTimer == null) { if (log.logTrace()) { log.trace("No idle client timeout configured, skipping timer reset"); } return; } if (log.logTrace()) { log.trace("Resetting idle client timer: " + System.identityHashCode(socket)); } // Store this in a local so we don't have to worry about // the value changing underneath us. long timeout = this.idleClientTimeout; // Cancel the existing task for this socket ... TimerTask curTask = (TimerTask) this.socketActivity.get(socket); if (curTask != null) { curTask.cancel(); } // And schedule a new one. TimerTask task = new IdleClientTimerTask(socket); this.socketActivity.put(socket, task); this.idleClientTimer.schedule(task, timeout); }
/* * Schedule a task. */ private void scheduleImpl(TimerTask task, long delay, long period, boolean fixed) { synchronized (impl) { if (impl.cancelled) { throw new IllegalStateException("luni.41"); // $NON-NLS-1$ } long when = delay + System.currentTimeMillis(); if (when < 0) { throw new IllegalArgumentException("luni.42"); // $NON-NLS-1$ } synchronized (task.lock) { if (task.isScheduled()) { throw new IllegalStateException("luni.43"); // $NON-NLS-1$ } if (task.cancelled) { throw new IllegalStateException("luni.44"); // $NON-NLS-1$ } task.when = when; task.period = period; task.fixedRate = fixed; } // insert the newTask into queue impl.insertTask(task); } }
/** The main timer loop. (See class comment.) */ private void mainLoop() { while (true) { try { TimerTask task; boolean taskFired; synchronized (queue) { // Wait for queue to become non-empty // But no more than timeout value. while (queue.isEmpty() && queue.newTasksMayBeScheduled) { queue.wait(THREAD_TIMEOUT); if (queue.isEmpty()) { break; } } if (queue.isEmpty()) break; // Queue is empty and will forever remain; die // Handle a possible change of the user clock queue.checkUserClockChange(); // Queue nonempty; look at first evt and do the right thing long currentTime, executionTime; task = queue.getMin(); synchronized (task.lock) { if (task.state == TimerTask.CANCELLED) { queue.removeMin(); continue; // No action required, poll queue again } currentTime = Timer.monotonicTimeMillis(); executionTime = task.nextExecutionTime; if (taskFired = (executionTime <= currentTime)) { if (task.period == 0) { // Non-repeating, remove queue.removeMin(); task.state = TimerTask.EXECUTED; } else { // Repeating task, reschedule queue.rescheduleMin( task.period < 0 ? currentTime - task.period : executionTime + task.period); } } } if (!taskFired) { // Task hasn't yet fired; wait long timeout = executionTime - currentTime; if (queue.hasUserClockTasks() && timeout > Timer.USER_CLOCK_CHECK_PERIOD) { timeout = Timer.USER_CLOCK_CHECK_PERIOD; } queue.wait(timeout); } } if (taskFired) { // Task fired; run it, holding no locks try { task.run(); } catch (Exception e) { // Cancel tasks that cause exceptions task.cancel(); } } } catch (InterruptedException e) { } } }
protected void deregisterSocket(Socket socket) { TimerTask task = (TimerTask) this.socketActivity.remove(socket); if (task != null) { task.cancel(); } super.deregisterSocket(socket); }
/** * Sets the nextExecutionTime associated with the head task to the specified value, and adjusts * priority queue accordingly. * * @param newTime new time to apply to head task execution. */ void rescheduleMin(long newTime) { final TimerTask task = queue[1]; task.nextExecutionTime = newTime; fixDown(1); if (task.isUserClock) { // Only the first execution is scheduled against the user clock. // Subsequent executions are scheduled based on delays. task.isUserClock = false; userClockTaskRemoved(); } }
public synchronized boolean pause() { if (timer == null) { return false; } stateSync.lock(); try { shouldRun = false; if (null != task) { task.cancel(); task = null; } animThread = null; try { final long periodx2 = 2L * (long) (1000.0f / (float) fps); Thread.sleep( periodx2 > 20L ? periodx2 : 20L); // max(2 x timer period, ~ 1/60), since we can't ctrl stopped threads } catch (InterruptedException e) { } } finally { stateSync.unlock(); } return true; }
/* * * Date By Description * MM/DD/YYYY * ---------- -- ----------- * 11/15/2002 INB Created. * */ public final void timerTask(TimerTask ttI) { try { if (ttI.getCode().equals(MetricsInterface.TT_METRICS)) { long now = System.currentTimeMillis(); Rmap frame = ((MetricsInterface) getObject()).calculateMetrics(lastTime, now); if (frame != null) { getSource().addChild(frame); } lastTime = now; } else if (ttI.getCode().equals(LogStatusInterface.TT_LOG_STATUS)) { ((LogStatusInterface) getObject()).logStatus("Is running"); } } catch (java.lang.Exception e) { } }
@Override public void onPause() { Log.d(TAG, "LoaderActivity paused"); super.onPause(); mTimerTask.cancel(); mTimerTask = null; }
/** Schedules the start and end tasks of the calendar item. */ public void scheduleTasks() { if (!executeNow) { timer.schedule(startTask, startDate); } else { startTask.run(); } timer.schedule(endTask, endDate); }
/** * Executes example. * * @param args Command line arguments, none required. * @throws GridException If example execution failed. */ public static void main(String[] args) throws Exception { Timer timer = new Timer("priceBars"); // Start grid. final Grid g = GridGain.start("examples/config/example-streamer.xml"); System.out.println(); System.out.println(">>> Streaming price bars example started."); try { TimerTask task = scheduleQuery(g, timer); streamData(g); // Force one more run to get final results. task.run(); timer.cancel(); // Reset all streamers on all nodes to make sure that // consecutive executions start from scratch. g.compute() .broadcast( new Runnable() { @Override public void run() { if (!ExamplesUtils.hasStreamer(g, "priceBars")) System.err.println( "Default streamer not found (is example-streamer.xml " + "configuration used on all nodes?)"); else { GridStreamer streamer = g.streamer("priceBars"); System.out.println("Clearing bars from streamer."); streamer.reset(); } } }) .get(); } finally { GridGain.stop(true); } }
public void expire() { if (updateState(ST_INIT, ST_EXPIRED)) { try { task.run(this); } catch (Throwable t) { parent.logger.warning( "An exception was thrown by " + TimerTask.class.getSimpleName() + ".", t); } } }
/** * Schedule the specified timer task for execution at the specified time with the specified * period, in milliseconds. If period is positive, the task is scheduled for repeated execution; * if period is zero, the task is scheduled for one-time execution. Time is specified in * Date.getTime() format. This method checks timer state, task state, and initial execution time, * but not period. * * @param task task to be scheduled. * @param userTime the user time at which task is to be executed or <tt>null</tt> if the delay is * specified * @param delay the delay in milliseconds before the task execution * @param period time in milliseconds between successive task executions. * @param isUserClock true if the time is bound to user clock * @throws IllegalArgumentException if <tt>time()</tt> is negative. * @throws IllegalStateException if task was already scheduled or cancelled, timer was cancelled, * or timer thread terminated. */ private void sched(TimerTask task, Date userTime, long delay, long period) { final boolean isUserClock = userTime != null; long time; if (isUserClock) { long t = userTime.getTime(); if (t < 0) { throw new IllegalArgumentException("Illegal execution time."); } time = Timer.userTimeFromStart(t); } else { time = Timer.monotonicTimeFromStart(JVM.monotonicTimeMillis() + delay); } synchronized (queue) { if (!queue.newTasksMayBeScheduled) { throw new IllegalStateException("Timer already cancelled."); } /* * If the TimerThread has exited without an error * it is restarted. See the commentary in TimerThread.run. */ if (thread == null || !thread.isAlive()) { thread = new TimerThread(queue); thread.start(); } synchronized (task.lock) { if (task.state != TimerTask.VIRGIN) { throw new IllegalStateException("Task already scheduled or cancelled"); } task.nextExecutionTime = time; task.period = period; task.state = TimerTask.SCHEDULED; task.isUserClock = isUserClock; } queue.add(task); if (queue.getMin() == task) queue.notify(); } }
public void expire() { if (!state.compareAndSet(ST_INIT, ST_EXPIRED)) { return; } try { task.run(this); } catch (Throwable t) { if (logger.isWarnEnabled()) { logger.warn("An exception was thrown by " + TimerTask.class.getSimpleName() + '.', t); } } }
public void messageReceived(int to, Message m) { DripMsg msg = (DripMsg) m; int newId = msg.get_metadata_id(); int newSeqno = msg.get_metadata_seqno(); log.debug("Received Msg: id=" + newId + ",seqno=" + newSeqno); if (newId != id) { log.debug("dropped, not ID " + id); return; } if ((newSeqno & ~DripConsts.DRIP_WAKEUP_BIT) == DripConsts.DRIP_SEQNO_NEWEST) { log.debug("dropped, a special seqno " + newSeqno); return; } switch (state) { case PROBING: seqno = newSeqno; log.info( "Receive: id=" + id + ",seqno=" + dripMsg.get_metadata_seqno() + " Heard Old Seqno"); incrementSeqno(); state = SENDING_SEQNO; case SENDING_SEQNO: if (seqno == newSeqno) { log.info( "Receive: id=" + id + ",seqno=" + dripMsg.get_metadata_seqno() + " Heard New Seqno"); trickle.cancel(); trickleTask.cancel(); sendDone(); } default: } }
public SimpleTimerTask setUp(final Runnable runnable, long delay) { synchronized (myTime2Task) { final long current = System.currentTimeMillis(); final long targetTime = current + delay; final SimpleTimerTask result = new SimpleTimerTask(targetTime, runnable, this); ArrayList<SimpleTimerTask> tasks = myTime2Task.get(targetTime); if (tasks == null) { tasks = new ArrayList<SimpleTimerTask>(2); myTime2Task.put(targetTime, tasks); } tasks.add(result); if (targetTime < myNextScheduledTime) { if (myNextProcessingTask != null) { myNextProcessingTask.cancel(); } scheduleNext(delay, targetTime); } return result; } }
/** Cancel any running Timer. */ private void cancelTimer() { if (task != null) { task.cancel(); task = null; } }
/** This method will be launched on separate thread for each Timer object. */ @Override public void run() { while (true) { final TimerTask task; synchronized (this) { // need to check cancelled inside the synchronized block if (cancelled) { return; } if (tasks.isEmpty()) { if (finished) { return; } // no tasks scheduled -- sleep until any task appear try { this.wait(); } catch (InterruptedException ignored) { } continue; } long currentTime = System.currentTimeMillis(); task = tasks.minimum(); long timeToSleep; synchronized (task.lock) { if (task.cancelled) { tasks.delete(0); continue; } // check the time to sleep for the first task scheduled timeToSleep = task.when - currentTime; } if (timeToSleep > 0) { // sleep! try { this.wait(timeToSleep); } catch (InterruptedException ignored) { } continue; } // no sleep is necessary before launching the task synchronized (task.lock) { int pos = 0; if (tasks.minimum().when != task.when) { pos = tasks.getTask(task); } if (task.cancelled) { tasks.delete(tasks.getTask(task)); continue; } // set time to schedule task.setScheduledTime(task.when); // remove task from queue tasks.delete(pos); // set when the next task should be launched if (task.period >= 0) { // this is a repeating task, if (task.fixedRate) { // task is scheduled at fixed rate task.when = task.when + task.period; } else { // task is scheduled at fixed delay task.when = System.currentTimeMillis() + task.period; } // insert this task into queue insertTask(task); } else { task.when = 0; } } } boolean taskCompletedNormally = false; try { task.run(); taskCompletedNormally = true; } finally { if (!taskCompletedNormally) { synchronized (this) { cancelled = true; } } } } }
/** Stops the cleaning thread. */ public void finalize() { clean.cancel(); }