Timer 和TimerTask 定时任务是否多线程

今天一个同事问过我这样一个问题。

Timer 启动一个任务，每个1秒钟执行一次 。如果第一次执行这个任务Task需要5秒。

那么第二次执行这个任务是在第2秒开始，还是在5秒开始。

问题就此开始了。

（1）如果是在第2秒执行这个任务。那么Task中的数据在同一个时间有两个线程在操作。这种操作

造成显现就会出现数据混乱。线程不安全。两个线程同时拿到一个全局变量index=1,先后加1.结果变成3.

第一个线程打印2,第二个线程打印3。这个现象就会造成线程不安全。（jvm现实应该没有这么傻。）

（2）所有可能性是第二次执行这个任务是从第5秒开始。它会等第一次执行完后在开始执行。

测试代码：

public class Task extends TimerTask {
    int index = 0;
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println(++index+"Thread "+this.scheduledExecutionTime());
                Thread.sleep(999);//休息1秒
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String args[]) {
        Timer timer = new Timer();
        Task task = new Task();
        timer.schedule(task, 1000,1000);
    }
}

打印结果：

1ThreadName1368694219239
2ThreadName1368694219239
3ThreadName1368694219239
4ThreadName1368694219239
5ThreadName1368694219239
6ThreadName1368694224235
7ThreadName1368694224235
8ThreadName1368694224235
9ThreadName1368694224235
10ThreadName1368694224235

这还不能充分证明我的猜想。

下面来看一下Timer和TimerTask的部分源码。

public class Timer {
    /**
     * The timer task queue.  This data structure is shared with the timer
     * thread.  The timer produces tasks, via its various schedule calls,
     * and the timer thread consumes, executing timer tasks as appropriate,
     * and removing them from the queue when they're obsolete.
     */
    private TaskQueue queue = new TaskQueue();

    /**
     * The timer thread.
     */
    private TimerThread thread = new TimerThread(queue);

在代码里我们经常创建一个Timer对象。Timer timer=new Timer();

这个时候会创建TimerThread(queue)对象。

TaskQueue队列是用来存放任务Task，可以多个，先进先出。只有等第一个执行完才能执行第二个依次执行。

TimerThread是用来控制Task任务执行。继续Thread类。先看一下TimerThread类。

  public void run() {
        try {
            mainLoop();
        } finally {
            // Someone killed this Thread, behave as if Timer cancelled
            synchronized(queue) {
                newTasksMayBeScheduled = false;
                queue.clear();  // Eliminate obsolete references
            }
        }
    }

这里继承Thread类并实习run方法。这个主要关注在run方法中  mainLoop();

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();//queue对象元素个数为空。等待被唤醒。
                    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) {
            }
        }
    }
}

来分析一下这代码，请注意我标红的代码。在创建Timer对象的时候，同时会初始化TimerThread ，并执行mainLoop这个方法。

这个时候queue对象被创建，但是queue对象没有元素。所以会执行queue.wait()。代码停止继续往下执行。queue等待被唤醒。

在执行Timer.schedule()方法中会调用sche()方法。此时会向queue中添加Task任务。 queue.add(task);并且唤醒queue对象queue.notify()。

回到mainLoop()方法，queue.notify()唤醒后将继续往下执行while中的代码，代码判断task任务状态是否被取消Task.cancelled。（可以通过Task.cancelled()方法取消）。

如果没有取消，在判断执行的时间。executionTime<currentTime 就执行task.run 启动任务。（注意task继承Runnable ，但是task.run并不是开启一个线程任务。只是普通

对象方法调用。这个线程是TimerThread开启的。）

  private void sched(TimerTask task, long time, long period) {
        if (time < 0)
            throw new IllegalArgumentException("Illegal execution time.");

        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();
        }
    }

如果executionTime>currentTime，那么queue.wait(executionTime-currentTime)。

说了这么半天，不知道大家明白了没有Timer.scheduel（task,1000,1000）在第二次调用任务是从第5秒开始。

那是因为Time.scheduel启动定时任务，并不是多线程。而是单线程在while循环调用task.run。所以第二次调用必须等待

第一次执行完毕或才能够继续往下执行。