android线程实现方法,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 queue = new PriorityQueue(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 {

@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 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 {

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

利用它做的一些效果：