/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.felix.useradmin.filestore;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* Provides a timer that can be reset.
*/
final class ResettableTimer {
private final ScheduledExecutorService m_executor;
private final Runnable m_task;
private final long m_timeout;
private final TimeUnit m_timeUnit;
private final AtomicReference m_futureRef;
/**
* Creates a new {@link ResettableTimer} calling a given task when a given
* timeout exceeds.
*
* @param task the task to execute upon timout, cannot be <code>null</code>;
* @param timeout the timeout value, > 0;
* @param unit the time unit of the timeout value, cannot be <code>null</code>.
*/
public ResettableTimer(Runnable task, long timeout, TimeUnit unit) {
this(new ScheduledThreadPoolExecutor(1), task, timeout, unit);
}
/**
* Creates a new {@link ResettableTimer} calling a given task when a given
* timeout exceeds.
*
* @param executor the executor to use to execute the task, cannot be <code>null</code>;
* @param task the task to execute upon timout, cannot be <code>null</code>;
* @param timeout the timeout value, > 0;
* @param unit the time unit of the timeout value, cannot be <code>null</code>.
*/
public ResettableTimer(ScheduledExecutorService executor, Runnable task, long timeout, TimeUnit unit) {
if (executor == null) {
throw new IllegalArgumentException("Executor cannot be null!");
}
if (task == null) {
throw new IllegalArgumentException("Task cannot be null!");
}
if (timeout <= 0) {
throw new IllegalArgumentException("Timeout cannot be negative!");
}
if (unit == null) {
throw new IllegalArgumentException("TimeUnit cannot be null!");
}
m_executor = executor;
m_task = task;
m_timeout = timeout;
m_timeUnit = unit;
m_futureRef = new AtomicReference();
}
/**
* Returns the state of this timer.
*
* @return <code>true</code> if this timer is shut down, <code>false</code> otherwise.
*/
public boolean isShutDown() {
return m_executor.isShutdown();
}
/**
* Schedules the task for execution with the contained timeout. If a task
* is already pending or running, it will be cancelled (not interrupted).
* The new task will be scheduled to run in now + timeout.
*/
public ScheduledFuture schedule() {
ScheduledFuture currentTask = cancelCurrentTask();
ScheduledFuture newTask = m_executor.schedule(m_task, m_timeout, m_timeUnit);
m_futureRef.compareAndSet(currentTask, newTask);
return newTask;
}
/**
* Shuts down this timer, allowing any pending tasks to execute. After this
* method is called, {@link #schedule()} may no longer be called.
*/
public void shutDown() {
m_executor.shutdown();
try {
m_executor.awaitTermination(2 * m_timeout, m_timeUnit);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
/**
* @return the current task, or <code>null</code> if no task is available.
*/
private ScheduledFuture cancelCurrentTask() {
ScheduledFuture currentTask = (ScheduledFuture) m_futureRef.get();
if (currentTask != null) {
// Doesn't matter for completed tasks...
currentTask.cancel(false /* mayInterruptIfRunning */);
}
return currentTask;
}
}