标签:
第二层是 {@link java.util.TimerThread},这个是{@link java.util.Timer}在初始化的时候创建并启动的一个线程,这个线程取任务并且执行。
/** * Creates a new timer whose associated thread has the specified name. * The associated thread does <i>not</i> * {@linkplain Thread#setDaemon run as a daemon}. * * @param name the name of the associated thread * @throws NullPointerException if {@code name} is null * @since 1.5 */ public Timer(String name) { thread.setName(name); thread.start(); }
public void run() { try { mainLoop(); } finally { // Someone killed this Thread, behave as if Timer cancelled synchronized(queue) { newTasksMayBeScheduled = false; queue.clear(); // Eliminate obsolete references } } }
/** * 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 while (queue.isEmpty() && newTasksMayBeScheduled) queue.wait(); if (queue.isEmpty()) break; // Queue is empty and will forever remain; die // 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 = System.currentTimeMillis(); 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 queue.wait(executionTime - currentTime); } if (taskFired) // Task fired; run it, holding no locks task.run(); } catch(InterruptedException e) { } } }
public void schedule(TimerTask task, long delay, long period) { if (delay < 0) throw new IllegalArgumentException("Negative delay."); if (period <= 0) throw new IllegalArgumentException("Non-positive period."); sched(task, System.currentTimeMillis()+delay, -period); }
/** * 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. * * @throws IllegalArgumentException if <tt>time</tt> is negative. * @throws IllegalStateException if task was already scheduled or * cancelled, timer was cancelled, or timer thread terminated. * @throws NullPointerException if {@code task} is null */ private void sched(TimerTask task, long time, long period) { if (time < 0) throw new IllegalArgumentException("Illegal execution time."); // Constrain value of period sufficiently to prevent numeric // overflow while still being effectively infinitely large. if (Math.abs(period) > (Long.MAX_VALUE >> 1)) period >>= 1; synchronized(queue) { if (!thread.newTasksMayBeScheduled) throw new IllegalStateException("Timer already cancelled."); 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; } queue.add(task); if (queue.getMin() == task) queue.notify(); } }1.两重锁,先锁队列queue,再锁task,task中有一个Object对象作为锁
/** * Establishes the heap invariant (described above) assuming the heap * satisfies the invariant except possibly for the leaf-node indexed by k * (which may have a nextExecutionTime less than its parent's). * * This method functions by "promoting" queue[k] up the hierarchy * (by swapping it with its parent) repeatedly until queue[k]'s * nextExecutionTime is greater than or equal to that of its parent. */ private void fixUp(int k) { while (k > 1) { int j = k >> 1; if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime) break; TimerTask tmp = queue[j]; queue[j] = queue[k]; queue[k] = tmp; k = j; } }
if (!taskFired) // Task hasn't yet fired; wait queue.wait(executionTime - currentTime);如果这期间又来了一个优先级更高(执行顺序更靠前)的task,入队列时调用fixUp把当前task排到队列头(优先级更高),然后notify这个queue打断这个wait,重新去取优先级更高的task。
/** * Adds a new task to the priority queue. */ void add(TimerTask task) { // Grow backing store if necessary if (size + 1 == queue.length) queue = Arrays.copyOf(queue, 2*queue.length); queue[++size] = task; fixUp(size); }如果到了执行时间(wait结束),在下次循环的时候,就执行该task。
/** * Establishes the heap invariant (described above) in the subtree * rooted at k, which is assumed to satisfy the heap invariant except * possibly for node k itself (which may have a nextExecutionTime greater * than its children's). * * This method functions by "demoting" queue[k] down the hierarchy * (by swapping it with its smaller child) repeatedly until queue[k]'s * nextExecutionTime is less than or equal to those of its children. */ private void fixDown(int k) { int j; while ((j = k << 1) <= size && j > 0) { if (j < size && queue[j].nextExecutionTime > queue[j+1].nextExecutionTime) j++; // j indexes smallest kid if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime) break; TimerTask tmp = queue[j]; queue[j] = queue[k]; queue[k] = tmp; k = j; } }对剩下的Task进行重新排序,把下次执行时间最小的转移到第一个任务的位置。
public static void test1() { timer.schedule(new TimerTask() { @Override public void run() { System.out.println("Time's up 1!---" + new Date().toString()); // SleepUtil.sleep(30000); } }, 2000 * 1000, 11 * 1000); timer.schedule(new TimerTask() { @Override public void run() { System.out.println("Time's up 2!---" + new Date().toString()); // SleepUtil.sleep(30000); } }, 1500 * 1000, 22 * 1000); timer.schedule(new TimerTask() { @Override public void run() { System.out.println("Time's up 3!---" + new Date().toString()); // SleepUtil.sleep(30000); } }, 5 * 1000, 333333 * 1000); }
public static void test3() { timer.schedule(new TimerTask() { @Override public void run() { System.out.println("Time's up 1!---" + new Date().toString()); SleepUtil.sleep(0); } }, 0, 2 * 1000); timer.schedule(new TimerTask() { @Override public void run() { System.out.println("Time's up 2!---" + new Date().toString()); SleepUtil.sleep(5000); } }, 0, 2 * 1000); // EvictionTimer.schedule(evictor, delay, delay); }TimerTask执行时间过长,超过了period,执行5s,period是2s,这样period相当于失效了。因为下次执行的时间是这样计算的,
标签:
原文地址:http://blog.csdn.net/xxcupid/article/details/51943461