一、传统线程机制
1. 使用类Thread实现
new Thread(){ @Override public void run() { while(true){ try{ Thread.sleep(2000); }catch (InterruptedException e) { e.printStackTrace(); } } } }.start();
2. 使用Runable对象来实现
new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub while(true){ try { Thread.sleep(2000); } catch (Exception e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()); } } }).start();
3. 总结
通过查看源代码可知，thread调用run()方法时，会先判断有没有设置target，也就是一个runable对象，如果有runable对象，那么就会直接调用runable对象的run方法；
@Override public void run() { if (target != null) { target.run(); } }
二、 传统定时器
传统定时器的实现，主要是通过Timer和TimerTask类来实现。
TimerTask是一个实现了run方法的类；
Timer是一个调度器；
Timer中的一些常见的方法：
public void schedule(TimerTask task, long delay)//这个方法是调度一个task，经过delay(ms)后开始进行调度，仅仅调度一次。public void schedule(TimerTask task, Data time)//在指定的时间点time上调度一次。public void schedule(TimerTask task, long delay, long period)//这个方法是调度一个task，在delay（ms）后开始调度，每次调度完后，最少等待period（ms）后才开始调度。public void schedule(TimerTask task, Date firstTime, long period)//和上一个方法类似，唯一的区别就是传入的第二个参数为第一次调度的时间。public void scheduleAtFixedRate(TimerTask task, long delay, long period)//调度一个task，在delay(ms)后开始调度，然后每经过period(ms)再次调度
Timer内部包装了一个线程，用来做独立于外部线程的调度，而TimerThread是一个default类型，默认情况下是引用不到的，是被Timer自己所使用的。
接下来看看Timer类调度方法的实现：
首先来看方法
public void schedule(TimerTask task, long delay) { if (delay < 0) throw new IllegalArgumentException("Negative delay."); sched(task, System.currentTimeMillis()+delay, 0); }
调用了sched方法，并传入了三个参数：task，时间点，0
再看另一个重载的方法：
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); }
同样传入了三个参数：task，时间点，以及period取反
最后再看一个重载的方法;
public void scheduleAtFixedRate(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); }
与上一个方法的唯一区别就是period没有取反。主要原因是不想另外再加一个参数来表示这两个方法。
来看sched方法的实现体：
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(); } }
queue为一个队列，我们先不看他数据结构，看到他在做这个操作的时候，发生了同步，所以在timer级别，这个是线程安全的，最后将task相关的参数赋值，主要包含nextExecutionTime（下一次执行时间），period（时间片），state（状态），然后将它放入queue队列中，做一次notify操作，为什么要做notify操作呢？看了后面的代码你就知道了。
queue属性的结构TaskQueue：
class TaskQueue { private TimerTask[] queue = new TimerTask[128]; private int size = 0; 可见，TaskQueue的结构很简单，为一个数组，加一个size，有点像ArrayList.。
这里面的方法大概意思是：
add(TimerTaskt)为增加一个任务
size()任务队列的长度
getMin()获取当前排序后最近需要执行的一个任务，下标为1，队列头部0是不做任何操作的。
get(inti)获取指定下标的数据，当然包括下标0.
removeMin()为删除当前最近执行的任务，也就是第一个元素，通常只调度一次的任务，在执行完后，调用此方法，就可以将TimerTask从队列中移除。
quickRmove(inti)删除指定的元素，一般来说是不会调用这个方法的，这个方法只有在Timer发生purge的时候，并且当对应的TimerTask调用了cancel方法的时候，才会被调用这个方法，也就是取消某个TimerTask，然后就会从队列中移除（注意如果任务在执行中是，还是仍然在执行中的，虽然在队列中被移除了），还有就是这个cancel方法并不是Timer的cancel方法而是TimerTask，一个是调度器的，一个是单个任务的，最后注意，这个quickRmove完成后，是将队列最后一个元素补充到这个位置，所以此时会造成顺序不一致的问题，后面会有方法进行回补。
rescheduleMin(long newTime)是重新设置当前执行的任务的下一次执行时间，并在队列中将其从新排序到合适的位置，而调用的是后面说的fixDown方法。
对于fixUp和fixDown方法来讲，前者是当新增一个task的时候，首先将元素放在队列的尾部，然后向前找是否有比自己还要晚执行的任务，如果有，就将两个任务的顺序进行交换一下。而fixDown正好相反，执行完第一个任务后，需要加上一个时间片得到下一次执行时间，从而需要将其顺序与后面的任务进行对比下。
其次可以看下fixDown的细节为：
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; } }
这种方式并非排序，而是找到一个合适的位置来交换，因为并不是通过队列逐个找的，而是每次移动一个二进制为，例如传入1的时候，接下来就是2、4、8、16这些位置，找到合适的位置放下即可，顺序未必是完全有序的，它只需要看到距离调度部分的越近的是有序性越强的时候就可以了，这样即可以保证一定的顺序性，达到较好的性能。
最后一个方法是heapify，其实就是将队列的后半截，全部做一次fixeDown的操作，这个操作主要是为了回补quickRemove方法，当大量的quickRmove后，顺序被打乱后，此时将一半的区域做一次非常简单的排序即可。
这些方法我们不在说源码了，只需要知道它提供了类似于ArrayList的东西来管理，内部有很多排序之类的处理，我们继续回到Timer，里面还有两个方法是：cancel()和方法purge()方法，其实就cancel方法来讲，一个取消操作，在测试中你会发现，如果一旦执行了这个方法timer就会结束掉，看下源码是什么呢：
public void cancel() { synchronized(queue) { thread.newTasksMayBeScheduled = false; queue.clear(); queue.notify(); // In case queue was already empty. } }
貌似仅仅将队列清空掉，然后设置了newTasksMayBeScheduled状态为false，最后让队列也调用了下notify操作，但是没有任何地方让线程结束掉，那么就要回到我们开始说的Timer中包含的thread为：TimerThread类了，在看这个类之前，再看下Timer中最后一个purge()类，当你对很多Task做了cancel操作后，此时通过调用purge方法实现对这些cancel掉的类空间的回收，上面已经提到，此时会造成顺序混乱，所以需要调用队里的heapify方法来完成顺序的重排，源码如下：
public int purge() { int result = 0; synchronized(queue) { for (int i = queue.size(); i > 0; i--) { if (queue.get(i).state == TimerTask.CANCELLED) { queue.quickRemove(i); result++; } } if (result != 0) queue.heapify(); } return result; }
那么调度呢，是如何调度的呢，那些notify，和清空队列是如何做到的呢？我们就要看看TimerThread类了，内部有一个属性是：newTasksMayBeScheduled，也就是我们开始所提及的那个参数在cancel的时候会被设置为false。