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

利用它做的一些效果：