util/concurrent/ScheduledExecutor.java

/*
 * @(#)ScheduledExecutor.java
 */

package java.util.concurrent;

/**
 * An <tt>Executor</tt> that can schedule tasks to run after a given delay,
 * or to execute periodically. This class is preferable to
 * <tt>java.util.Timer</tt> when multiple worker threads are needed,
 * or when the additional flexibility or capabilities of
 * <tt>ThreadExecutor</tt> are required.  Tasks submitted using the
 * <tt>execute</tt> method are scheduled as if they had a requested
 * delay of zero. 
 *
 * @since 1.5
 * @see Executors
 *
 * @spec JSR-166
 */
public class ScheduledExecutor extends ThreadPoolExecutor {

    /**
     * Creates a new ScheduledExecutor with the given initial parameters.
     * 
     * @param minThreads the minimum number of threads to keep in the pool,
     * even if they are idle
     * @param maxThreads the maximum number of threads to allow in the pool
     * @param keepAliveTime when the number of threads is greater than
     * the minimum, this is the maximum time that excess idle threads
     * will wait for new tasks before terminating
     * @param granularity the time unit for the keepAliveTime argument
     */
    public ScheduledExecutor(int minThreads,
                             int maxThreads,
                             long keepAliveTime,
                             TimeUnit granularity) {
        super(minThreads, maxThreads, keepAliveTime, granularity,
              new PriorityBlockingQueue());
    }

    /**
     * A delayed or periodic task that can be run by a <tt>ScheduledExecutor</tt>.
     */
    public abstract class ScheduledTask implements Runnable, Cancellable, Comparable {

        /**
         * Returns the time interval until this task can run next,
         * in the specified unit.
         *
         * @param unit time unit for interval returned
         * @return time interval until task can run again
         */
        long getExecutionTime(TimeUnit unit) {
            return 0;
        }

        /**
         * Constructs scheduled task.
         * @fixme default package access?
         */
        ScheduledTask() {
        }
    }

    /**
     * A delayed result-bearing action that can be run by a <tt>ScheduledExecutor</tt>.
     *
     * @see Future
     */
    public abstract class ScheduledFutureTask extends ScheduledTask implements Future {

        /**
         * Constructs scheduled future task.
         * @fixme default package access?
         */
        ScheduledFutureTask() {
        }
    }

    /**
     * Creates a delayed task that can be scheduled on this executor.
     * A delayed task becomes eligible to run after the specified delay expires.
     *
     * @param r ???
     * @param delay ???
     * @param unit ???
     * @return a task that becomes eligible to run after the specified delay
     */
    public static ScheduledTask newDelayedTask(Runnable r, long delay, TimeUnit unit) {
        return null;
    }

    /**
     * Creates a periodic task.  A periodic task is like a
     * delayed task, except that upon its completion, it is rescheduled
     * for repeated execution after the specified delay.  Periodic tasks
     * will run no more than once every delay cycle, but are subject to
     * drift over time.
     *
     * @param r ???
     * @param delay ???
     * @param period ???
     * @param unit ???
     * @return a task that executes periodically
     */
    public static ScheduledTask newPeriodicTask(Runnable r, long delay, long period, TimeUnit unit) {
        return null;
    }

    /**
     * Creates a fixed-rate task.  A fixed rate task is like
     * a periodic task, except that upon completion, it is rescheduled
     * to run at the specified delay after the scheduled start time of
     * the current execution.  ScheduledExecutor attempts to execute
     * fixed rate tasks at the desired frequency, even if the previous
     * execution was delayed.
     *
     * @param r ???
     * @param delay ???
     * @param period ???
     * @param unit ???
     * @return a task that executes periodically at a fixed rate
     */
    public static ScheduledTask newFixedRateTask(Runnable r, long delay, long period, TimeUnit unit) {
        return null;
    }

    /**
     * Creates a delayed Callable task, which computes a result.
     *
     * @param c ???
     * @param delay ???
     * @param unit ???
     * @return a task that computes a result after the specified delay
     */
    public static ScheduledFutureTask newDelayedFutureTask(Callable c, long delay, TimeUnit unit) {
        return null;
    }

    /**
     * Schedules a ScheduledTask for execution.
     *
     * @param t ???
     * @throws CannotExecuteException if command cannot be scheduled for
     * execution
     */
    public void schedule(ScheduledTask t) {
    }
}


/*
 * @fixme static factories on internal or external classes?
 */
Revision:	1.1
Committed:	Wed May 14 21:30:47 2003 UTC (21 years ago) by tim
Branch:	MAIN
Log Message:	Moved main source rooted at . to ./src/main Moved test source rooted at ./etc/testcases to ./src/test
#	Content
1	/*
2	* @(#)ScheduledExecutor.java
3	*/
4
5	package java.util.concurrent;
6
7	/**
8	* An <tt>Executor</tt> that can schedule tasks to run after a given delay,
9	* or to execute periodically. This class is preferable to
10	* <tt>java.util.Timer</tt> when multiple worker threads are needed,
11	* or when the additional flexibility or capabilities of
12	* <tt>ThreadExecutor</tt> are required. Tasks submitted using the
13	* <tt>execute</tt> method are scheduled as if they had a requested
14	* delay of zero.
15	*
16	* @since 1.5
17	* @see Executors
18	*
19	* @spec JSR-166
20	*/
21	public class ScheduledExecutor extends ThreadPoolExecutor {
22
23	/**
24	* Creates a new ScheduledExecutor with the given initial parameters.
25	*
26	* @param minThreads the minimum number of threads to keep in the pool,
27	* even if they are idle
28	* @param maxThreads the maximum number of threads to allow in the pool
29	* @param keepAliveTime when the number of threads is greater than
30	* the minimum, this is the maximum time that excess idle threads
31	* will wait for new tasks before terminating
32	* @param granularity the time unit for the keepAliveTime argument
33	*/
34	public ScheduledExecutor(int minThreads,
35	int maxThreads,
36	long keepAliveTime,
37	TimeUnit granularity) {
38	super(minThreads, maxThreads, keepAliveTime, granularity,
39	new PriorityBlockingQueue());
40	}
41
42	/**
43	* A delayed or periodic task that can be run by a <tt>ScheduledExecutor</tt>.
44	*/
45	public abstract class ScheduledTask implements Runnable, Cancellable, Comparable {
46
47	/**
48	* Returns the time interval until this task can run next,
49	* in the specified unit.
50	*
51	* @param unit time unit for interval returned
52	* @return time interval until task can run again
53	*/
54	long getExecutionTime(TimeUnit unit) {
55	return 0;
56	}
57
58	/**
59	* Constructs scheduled task.
60	* @fixme default package access?
61	*/
62	ScheduledTask() {
63	}
64	}
65
66	/**
67	* A delayed result-bearing action that can be run by a <tt>ScheduledExecutor</tt>.
68	*
69	* @see Future
70	*/
71	public abstract class ScheduledFutureTask extends ScheduledTask implements Future {
72
73	/**
74	* Constructs scheduled future task.
75	* @fixme default package access?
76	*/
77	ScheduledFutureTask() {
78	}
79	}
80
81	/**
82	* Creates a delayed task that can be scheduled on this executor.
83	* A delayed task becomes eligible to run after the specified delay expires.
84	*
85	* @param r ???
86	* @param delay ???
87	* @param unit ???
88	* @return a task that becomes eligible to run after the specified delay
89	*/
90	public static ScheduledTask newDelayedTask(Runnable r, long delay, TimeUnit unit) {
91	return null;
92	}
93
94	/**
95	* Creates a periodic task. A periodic task is like a
96	* delayed task, except that upon its completion, it is rescheduled
97	* for repeated execution after the specified delay. Periodic tasks
98	* will run no more than once every delay cycle, but are subject to
99	* drift over time.
100	*
101	* @param r ???
102	* @param delay ???
103	* @param period ???
104	* @param unit ???
105	* @return a task that executes periodically
106	*/
107	public static ScheduledTask newPeriodicTask(Runnable r, long delay, long period, TimeUnit unit) {
108	return null;
109	}
110
111	/**
112	* Creates a fixed-rate task. A fixed rate task is like
113	* a periodic task, except that upon completion, it is rescheduled
114	* to run at the specified delay after the scheduled start time of
115	* the current execution. ScheduledExecutor attempts to execute
116	* fixed rate tasks at the desired frequency, even if the previous
117	* execution was delayed.
118	*
119	* @param r ???
120	* @param delay ???
121	* @param period ???
122	* @param unit ???
123	* @return a task that executes periodically at a fixed rate
124	*/
125	public static ScheduledTask newFixedRateTask(Runnable r, long delay, long period, TimeUnit unit) {
126	return null;
127	}
128
129	/**
130	* Creates a delayed Callable task, which computes a result.
131	*
132	* @param c ???
133	* @param delay ???
134	* @param unit ???
135	* @return a task that computes a result after the specified delay
136	*/
137	public static ScheduledFutureTask newDelayedFutureTask(Callable c, long delay, TimeUnit unit) {
138	return null;
139	}
140
141	/**
142	* Schedules a ScheduledTask for execution.
143	*
144	* @param t ???
145	* @throws CannotExecuteException if command cannot be scheduled for
146	* execution
147	*/
148	public void schedule(ScheduledTask t) {
149	}
150	}
151
152
153	/*
154	* @fixme static factories on internal or external classes?
155	*/