scheduledthreadpoolexecutor.java

来自「SRI international 发布的OAA框架软件」· Java 代码 · 共 548 行 · 第 1/2 页

     * even if they are idle.
     * @param threadFactory the factory to use when the executor
     * creates a new thread.
     * @param handler the handler to use when execution is blocked
     * because the thread bounds and queue capacities are reached.
     * @throws NullPointerException if threadFactory or handler is null
     */
    public ScheduledThreadPoolExecutor(int corePoolSize,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayQueue(), threadFactory, handler);
    }

    public ScheduledFuture schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        long triggerTime = now() + unit.toNanos(delay);
        ScheduledFutureTask t =
            new ScheduledFutureTask(command, null, triggerTime);
        delayedExecute(t);
        return t;
    }

    public ScheduledFuture schedule(Callable callable,
                                    long delay,
                                    TimeUnit unit) {
        if (callable == null || unit == null)
            throw new NullPointerException();
        if (delay < 0) delay = 0;
        long triggerTime = now() + unit.toNanos(delay);
        ScheduledFutureTask t =
            new ScheduledFutureTask(callable, triggerTime);
        delayedExecute(t);
        return t;
    }

    public ScheduledFuture scheduleAtFixedRate(Runnable command,
                                               long initialDelay,
                                               long period,
                                               TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (period <= 0)
            throw new IllegalArgumentException();
        if (initialDelay < 0) initialDelay = 0;
        long triggerTime = now() + unit.toNanos(initialDelay);
        ScheduledFutureTask t =
            new ScheduledFutureTask(command,
                                    null,
                                    triggerTime,
                                    unit.toNanos(period));
        delayedExecute(t);
        return t;
    }

    public ScheduledFuture scheduleWithFixedDelay(Runnable command,
                                                  long initialDelay,
                                                  long delay,
                                                  TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (delay <= 0)
            throw new IllegalArgumentException();
        if (initialDelay < 0) initialDelay = 0;
        long triggerTime = now() + unit.toNanos(initialDelay);
        ScheduledFutureTask t =
            new ScheduledFutureTask(command,
                                    null,
                                    triggerTime,
                                    unit.toNanos(-delay));
        delayedExecute(t);
        return t;
    }


    /**
     * Execute command with zero required delay. This has effect
     * equivalent to <tt>schedule(command, 0, anyUnit)</tt>.  Note
     * that inspections of the queue and of the list returned by
     * <tt>shutdownNow</tt> will access the zero-delayed
     * {@link ScheduledFuture}, not the <tt>command</tt> itself.
     *
     * @param command the task to execute
     * @throws RejectedExecutionException at discretion of
     * <tt>RejectedExecutionHandler</tt>, if task cannot be accepted
     * for execution because the executor has been shut down.
     * @throws NullPointerException if command is null
     */
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        schedule(command, 0, TimeUnit.NANOSECONDS);
    }

    // Override AbstractExecutorService methods

    public Future submit(Runnable task) {
        return schedule(task, 0, TimeUnit.NANOSECONDS);
    }

    public  Future submit(Runnable task, Object result) {
        return schedule(Executors.callable(task, result),
                        0, TimeUnit.NANOSECONDS);
    }

    public  Future submit(Callable task) {
        return schedule(task, 0, TimeUnit.NANOSECONDS);
    }

    /**
     * Set policy on whether to continue executing existing periodic
     * tasks even when this executor has been <tt>shutdown</tt>. In
     * this case, these tasks will only terminate upon
     * <tt>shutdownNow</tt>, or after setting the policy to
     * <tt>false</tt> when already shutdown. This value is by default
     * false.
     * @param value if true, continue after shutdown, else don't.
     * @see #getExecuteExistingDelayedTasksAfterShutdownPolicy
     */
    public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) {
        continueExistingPeriodicTasksAfterShutdown = value;
        if (!value && isShutdown())
            cancelUnwantedTasks();
    }

    /**
     * Get the policy on whether to continue executing existing
     * periodic tasks even when this executor has been
     * <tt>shutdown</tt>. In this case, these tasks will only
     * terminate upon <tt>shutdownNow</tt> or after setting the policy
     * to <tt>false</tt> when already shutdown. This value is by
     * default false.
     * @return true if will continue after shutdown.
     * @see #setContinueExistingPeriodicTasksAfterShutdownPolicy
     */
    public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy() {
        return continueExistingPeriodicTasksAfterShutdown;
    }

    /**
     * Set policy on whether to execute existing delayed
     * tasks even when this executor has been <tt>shutdown</tt>. In
     * this case, these tasks will only terminate upon
     * <tt>shutdownNow</tt>, or after setting the policy to
     * <tt>false</tt> when already shutdown. This value is by default
     * true.
     * @param value if true, execute after shutdown, else don't.
     * @see #getExecuteExistingDelayedTasksAfterShutdownPolicy
     */
    public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) {
        executeExistingDelayedTasksAfterShutdown = value;
        if (!value && isShutdown())
            cancelUnwantedTasks();
    }

    /**
     * Get policy on whether to execute existing delayed
     * tasks even when this executor has been <tt>shutdown</tt>. In
     * this case, these tasks will only terminate upon
     * <tt>shutdownNow</tt>, or after setting the policy to
     * <tt>false</tt> when already shutdown. This value is by default
     * true.
     * @return true if will execute after shutdown.
     * @see #setExecuteExistingDelayedTasksAfterShutdownPolicy
     */
    public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy() {
        return executeExistingDelayedTasksAfterShutdown;
    }


    /**
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks will be accepted. If the
     * <tt>ExecuteExistingDelayedTasksAfterShutdownPolicy</tt> has
     * been set <tt>false</tt>, existing delayed tasks whose delays
     * have not yet elapsed are cancelled. And unless the
     * <tt>ContinueExistingPeriodicTasksAfterShutdownPolicy</tt> has
     * been set <tt>true</tt>, future executions of existing periodic
     * tasks will be cancelled.
     */
    public void shutdown() {
        cancelUnwantedTasks();
        super.shutdown();
    }

    /**
     * Attempts to stop all actively executing tasks, halts the
     * processing of waiting tasks, and returns a list of the tasks that were
     * awaiting execution.
     *
     * <p>There are no guarantees beyond best-effort attempts to stop
     * processing actively executing tasks.  This implementation
     * cancels tasks via {@link Thread#interrupt}, so if any tasks mask or
     * fail to respond to interrupts, they may never terminate.
     *
     * @return list of tasks that never commenced execution.  Each
     * element of this list is a {@link ScheduledFuture},
     * including those tasks submitted using <tt>execute</tt>, which
     * are for scheduling purposes used as the basis of a zero-delay
     * <tt>ScheduledFuture</tt>.
     */
    public List shutdownNow() {
        return super.shutdownNow();
    }

    /**
     * Returns the task queue used by this executor.  Each element of
     * this queue is a {@link ScheduledFuture}, including those
     * tasks submitted using <tt>execute</tt> which are for scheduling
     * purposes used as the basis of a zero-delay
     * <tt>ScheduledFuture</tt>. Iteration over this queue is
     * <em>not</em> guaranteed to traverse tasks in the order in
     * which they will execute.
     *
     * @return the task queue
     */
    public BlockingQueue getQueue() {
        return super.getQueue();
    }

//    /**
//     * An annoying wrapper class to convince generics compiler to
//     * use a DelayQueue<ScheduledFutureTask> as a BlockingQueue<Runnable>
//     */
//    private static class DelayedWorkQueue
//        extends AbstractCollection
//        implements BlockingQueue {
//
//        private final DelayQueue dq = new DelayQueue();
//        public Runnable poll() { return dq.poll(); }
//        public Runnable peek() { return dq.peek(); }
//        public Runnable take() throws InterruptedException { return dq.take(); }
//        public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
//            return dq.poll(timeout, unit);
//        }
//
//        public boolean add(Runnable x) { return dq.add((ScheduledFutureTask)x); }
//        public boolean offer(Runnable x) { return dq.offer((ScheduledFutureTask)x); }
//        public void put(Runnable x)  {
//            dq.put((ScheduledFutureTask)x);
//        }
//        public boolean offer(Runnable x, long timeout, TimeUnit unit) {
//            return dq.offer((ScheduledFutureTask)x, timeout, unit);
//        }
//
//        public Runnable remove() { return dq.remove(); }
//        public Runnable element() { return dq.element(); }
//        public void clear() { dq.clear(); }
//        public int drainTo(Collection c) { return dq.drainTo(c); }
//        public int drainTo(Collection c, int maxElements) {
//            return dq.drainTo(c, maxElements);
//        }
//
//        public int remainingCapacity() { return dq.remainingCapacity(); }
//        public boolean remove(Object x) { return dq.remove(x); }
//        public boolean contains(Object x) { return dq.contains(x); }
//        public int size() { return dq.size(); }
//        public boolean isEmpty() { return dq.isEmpty(); }
//        public Object[] toArray() { return dq.toArray(); }
//        public Object[] toArray(Object[] array) { return dq.toArray(array); }
//        public Iterator iterator() {
//            return new Iterator() {
//                private Iterator it = dq.iterator();
//                public boolean hasNext() { return it.hasNext(); }
//                public Runnable next() { return it.next(); }
//                public void remove() {  it.remove(); }
//            };
//        }
//    }
}