Java多线程学习（三）----线程调度

1、线程调用

线程抢占资源本来就是随机的，无序的，没有规律可行的。但是在某种场景下对线程有着特定的要求，如进程中有着两个线程在运行，但是希望A线程一定要在B线程执行到一半就要结束了。这就需要通过线程调度来调节线程的运行规律了。
线程调度的方法还挺多中的，这里就介绍几种吧：setPriority(int newPriority)方法设置线程优先级、 sleep(long millis)方法控制线程进入睡眠、join()方法强制运行完本线程、 yield()方法把线程抢占到的CPU资源礼让出去，然后再与别的线程一起抢占CPU资源等。

2、通过设置优先级别进行线程调度

通过调用setPriority(int newPriority)方法设置线程优先级，线程的默认优先级是5，最大为10，最先为1，Thread有对应属性字段：MAX_PRIORITY代表着线程最大值， MIN_PRIORITY代表线程最低优先级，NORM_PRIORITY代表着优先级的默认值。
把线程的优先级设置为最大值，不一定可以抢占的到CPU线程，只是抢占到的概率大了很多而已，同理把线程的优先级设置为最小值，也不会代表着线程抢不到CPU的资源，而是抢占到的概率很小而已。

1）例子

主线程与子线程运行同样的代码，设置子线程优先级高，主线程优先级低：
子线程类：

package com.zwy2;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

主线程代码：

package com.zwy2;

public class test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        Thread thread=Thread.currentThread();
        myThread.setPriority(8);
        thread.setPriority(4);
        myThread.start();


        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

运行结果：运行的规律还是随机的

3、通过设置线程进入睡眠状态调节线程运行规律

调用线程的sleep方法并设置睡眠时间后，本线程进入了睡眠状态（阻塞状态），把线程占用的CPU资源释放掉，让其他线程有抢占CPU的资源，睡眠结束后，线程又重新加入抢占CPU资源中。

1）例子

通过设置主线程与子线程的睡眠时间不同来看看效果，设置主线程的睡眠时间为子线程的两倍：
子线程类代码：

package com.zwy2;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

主线程类代码：

package com.zwy2;

public class test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();

        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：主线程运行一次后，子线程基本上运行两次，因为主线程睡眠的时间足够子线程运行两次，有的多以两次是因为运行两次后，子线程和主线程都结束了睡眠，重新开始随机抢占CPU资源。

4、通过join()方法调节线程运行规律

调用join()方法进行调度，是调用这个方法后可以强制停下正在运行的线程，然后让调用了join方法的线程运行，直到这个线程结束后才可以运行其他线程。join方法实质上就是强制把CPU强过来给线程使用，直到线程结束才会释放CPU资源。

1）例子

在主线运行到2的时候，子线程通过调用join方法，使子线程运行完。
子线程类代码：

package com.zwy2;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

主线程代码：

package com.zwy2;

public class test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();

        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i==2){
                try {
                    myThread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：在主线程运行到2的时候，运行子线直到结束才继续运行主线程

5、通过yiled()方法调节线程运行规律

yield方法的功能有点与join方法相反，join方法是强制停止正在运行的线程，然后运行调用了join方法的这个线程直到结束，才释放CPU资源。而调用yield方法是把本线程抢占的CPU资源释放出去，然后在与别的线程进行抢占。这个方法就是一中礼让的方式，抢到的第一次先礼让出去，再参与抢占CPU资源。

1）例子

主线程再运行到2的时候，把抢占到的CPU资源礼让出去，再参与CPU资源的抢占
子线程类代码：

package com.zwy2;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

主线程代码：

package com.zwy2;

public class test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i==5){
                System.out.println(Thread.currentThread().getName()+":主线程礼让");
                Thread.yield();
            }
        }
    }
}

运行结果：在主线程礼让的时候，子线程还是没有抓住机会，每次运行都是随机的，都是不一样的结果