Android中让多个线程顺序执行探究

线程调度是指按照特定机制为多个线程分配CPU的使用权。
有两种调度模型：分时调度模型和抢占式调度模型。　　
分时调度模型：是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片。
抢占式调度模型：是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。处于运行状态的线程会一直运行，直至它不得不放弃CPU。一个线程会因为以下原因而放弃CPU：
1 、java虚拟机让当前线程暂时放弃CPU，转到就绪状态，使其它线程或者运行机会。
2、 当前线程因为某些原因而进入阻塞状态
3、 线程结束运行
需要注意的是，线程的调度不是跨平台的，它不仅仅取决于java虚拟机，还依赖于操作系统。在某些操作系统中，只要运行中的线程没有遇到阻塞，就不会放弃CPU；在某些操作系统中，即使线程没有遇到阻塞，也会运行一段时间后放弃CPU，给其它线程运行的机会，java的线程调度是不分时的，同时启动多个线程后，不能保证各个线程轮流获得均等的CPU时间片。如果希望明确地让一个线程给另外一个线程运行的机会，可以采取以下办法之一：调整各个线程的优先级、让处于运行状态的线程调用、Thread.sleep()方法、让处于运行状态的线程调用Thread.yield()方法、让处于运行状态的线程调用另一个线程的join()方法

所以，让多个线程顺序执行有三个确切的办法：
1、改变线程的优先级（不同的系统上可能并不会按照优先级来执行）
2、调用join()方法，一个线程在run中调用join()方法时，会阻塞当前线程，而让新加入的线程执行完再执行本线程
3、第三个方法是我自己想出来的，就是使用PriorityQueue优先队列，PriorityQueue有这样一个特征，就是可以让队列中某个优先级最高元素最先出来，所以利用这个特性，可以让我们想要哪个线程先执行就先执行，最后通过线程的State来判断该线程是否执行完毕，再执行下一个线程，这个方法的一个好处是各线程之间不必使用join来执行了，各个线程可以独立出来。

PriorityQueue的用法：

PriorityQueue<Integer> queue = new PriorityQueue<Integer>(11, new MyComparator());        queue.add(3);        queue.add(1);        queue.add(-2);        queue.add(4);        queue.add(6);        queue.add(9);        queue.add(2);        queue.offer(8);        while (!queue.isEmpty()) {            Log.v("zxy", queue.poll() + "");//9864321-2        }public static class MyComparator implements Serializable, Comparator<Integer> {        @Override        public int compare(Integer lhs, Integer rhs) {            int value = lhs > rhs ? 1 : lhs < rhs ? -1 : 0;            return value;        }    }

上面这个示例就是优先队列的基本用法，它可以传入一个我们自定义的比较器，利用这个比较器我们可以自己定义队列中元素的顺序。其中compare（）方法中的返回值：
1、>0：代表lhs>rhs
2、<0：代表rhs>lhs
3、==0：代表lhs==rhs

而PriorityQueue中有这么几个方法：
1、queue.poll()：表示从队列中取出队首上的元素，且取出后remove掉这个元素
2、queue.peek()：表示从队列中取出队首上的元素，且取出后不remove掉这个元素
3、queue.add()：表示添加一个元素
4、queue.clear()：表示清空队列
5、queue.remove()：表示移除某个元素
6、queue.size()：表示队列的size

利用优先队列实现多个线程顺序执行

final PriorityQueue<Thread> queue = new PriorityQueue<>(11, new MyThreadComparator());        queue.add(thread1);        queue.add(thread2);        queue.add(thread3);        queue.add(thread5);        queue.add(thread7);        queue.add(thread6);        queue.add(thread4);        boolean flag = false;        Thread mThread = null;        int i=0;        int size = queue.size();        while (!queue.isEmpty()) {            if(!flag){                mThread = queue.poll();                mThread.start();                flag = true;                i++;            }            if(mThread.getState()== Thread.State.TERMINATED && !queue.isEmpty()){                if(size==i){                    break;                }                if(size==(i+1)){                    mThread = queue.peek();                    mThread.start();                    i++;                }else {                    mThread = queue.poll();                    mThread.start();                    i++;                }            }        }public static class MyThreadComparator implements Serializable, Comparator<Thread> {        @Override        public int compare(Thread lhs, Thread rhs) {            int value = lhs.getPriority() < rhs.getPriority() ? 1 : lhs.getPriority() > rhs.getPriority() ? -1 : 0;            return value;        }    }

这里每创建一个线程我都给它设置了一个自带的优先级（其实这个只是一个标志，你也可以用任何东西作为标志，比如采用），用来表示该线程的优先级：

Thread thread1 = new Thread( new Runnable() {            @Override            public void run() {                try {                    Thread.sleep(4000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                Log.v("zxy", "result—>thread1");            }        });        thread1.setPriority(3);

利用它做的一些效果：