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