Java多线程(一) —— 传统线程技术

一、传统线程机制

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。