Java多线程--线程的调度

       java虚拟机会按照特定的机制为程序中的每个线程分配CPU的使用权，这种机制被称为线程的调度。　　

　　在计算机中，线程调度有两种模型，分别是分时调度模型和抢占式调度模型。

分时调度模型：

　　指让所有的线程轮流获得CPU的使用权，并且平均分配每个线程占用CPU的时间片。

抢占式调度模型：

　　让可运行迟中优先级高的线程优先占用CPU，而对于优先级相同的线程，随机选择一个线程使其占用CPU，当它失去了CPU的使用权后，再随机选择其它线程获取CPU的使用权。

　　java虚拟机默认采用抢占式调度模型，但在某些特定的需求下需要改变这种模型，由线程自己来控制CPU的调度。

　

线程的优先级：

　　如果要对线程进行调度，最直接的方法就是设置线程的优先级。　

　　在线程中有优先级的机制，线程的优先级用1~10之间的整数来表示，数字越大则表示优先级越高。除了数字，还可以使用Thread类中提供的三个静态常量表示线程的优先级，他们分别是：MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORIY。

　　优先级高的线程获得CPU执行的机会越大，而优先级低的线程获得CPU执行的机会越小。在默认情况下，每个线程都有自己的优先级，例如main线程具有普通优先级。线程优先级不是固定不变的，通过调用Thread类的setPriority(int newPriority)方法可以进行改变，setPriority()方法的数newPriority接收1~10之间的数或者Thread类的三个静态常量

@SpringBootTest
//定义MaxPriority，实现Runnable接口
class MaxPriority implements Runnable{
    //实现接口中的run()方法
    @Override
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(Thread.currentThread().getName() + "正在输出！");
        }
    }
}
//定义MinPriority，实现Runnable接口
class MinPriority implements Runnable{
    //实现接口中的run()方法
    @Override
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(Thread.currentThread().getName() + "正在输出！");
        }
    }
}
public class Example {
    public static void main(String[] args) {
        //创建两个线程
        Thread minPriority = new Thread(new MinPriority(),"优先级较低的线程");
        Thread maxPriority = new Thread(new MaxPriority(),"优先级较高的线程");
        //设置线程的优先级为1
        minPriority.setPriority(1);
        //设置线程的优先级为10
        maxPriority.setPriority(10);
        //开启两个线程
        minPriority.start();
        maxPriority.start();
    }
 }

程序运行结果：

 　　优先级较高的maxPriority线程会先运行，运行完毕后优先级较低的minPriority线程才开始运行。

 

线程休眠

　　如果希望人为地控制线程，使正在运行的线程暂停，将CPU让给别的线程，这时可以使用静态方法sleep(long millis)方法，该方法可以让当前正在运行的线程暂停一段时间，进入休眠等待状态。当前线程调用sleep(long millis)方法后，在指定时间（参数 millis）内是不会执行的，这样其它的线程就可以得到执行的机会了。

　　sleep(long millis)方法声明抛出InterruptedExcption异常，因此在调用该方法时应该捕获异常，或者声明抛出异常。

@SpringBootTest
//定义SleepThread，实现Runnable接口
class SleepThread implements Runnable{
    //实现接口中的run()方法
    @Override
    public void run() {
        for (int i = 0; i <5; i++) {
            if (i == 3){
                try {
                    Thread.sleep(2000);//当前线程休眠2秒
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println("线程一正在输出：" + i);
            try {
                Thread.sleep(500); //当前线程休眠500毫秒
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
public class Example {
    public static void main(String[] args) throws Exception{
        //创建一个线程
        new Thread(new SleepThread()).start();
        for (int i = 0; i < 10; i++) {
            if (i ==5){
                Thread.sleep(2000);//当前线程休眠2秒
            }
            System.out.println("主线程正在输出：" + i);
            Thread.sleep(500); //当前线程休眠500毫秒
        }
    }
 }

运行结果：

　　17行和33行的目的是是让一个线程在一次打印后休眠500ms,从而使另一个线程获得执行机会，这样就可以实现两个线程的交替实行。

　　在线程一的for循环中，当i==3时，调用Thread的sleep(2000)方法，使线程休眠2s，主线程得到执行机会，接着输出了3和4，这说明线程一进入了休眠等待状态。

　　在主线程的for循环中，当i ==5时，也调用了Thread的sleep(2000)方法，使线程休眠2s，当主线程2s休眠结束后，两个线程才会恢复交替执行。

　　sleep()是静态方法，只能控制当前正在运行的线程休眠，而不能控制其他线程休眠。当线程休眠结束后，线程就会返回就绪状态，而不是立刻开始运行。

线程让步

　　线程让步可以通过yield()方法来实现，该方法和sleep()方法有点相似，都可以让当前正在运行的线程暂停，区别在于yield()方法不会阻塞线程，它只是将线程转换成就绪状态，让系统的调度器重新调度一次。yield()方法结束后，只有与当前线程优先级相同或者更高的线程才能获得执行机会。

@SpringBootTest
//定义YieldThread，继承Thread类
class YieldThread extends Thread{
    //定义一个有参的构造方法
    public YieldThread(String name) {
        super(name);
    }
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
            if (i == 3) {
                System.out.println("线程让步：");
                Thread.yield();
            }
        }
    }
}
public class Example {
    public static void main(String[] args) throws Exception{
        //创建两个线程
       Thread t1 = new YieldThread("线程A");
       Thread t2 = new YieldThread("线程B");
         //开启两个线程
        t1.start();
        t2.start();
    }
 }

运行结果：

 　　如图，当线程B输出3以后，会做出让步，线程A继续执行，同样，当线程A输出3后，也会做出让步，线程B继续执行。

线程插队

　　当在某个线程中调用其他线程的join()方法时，调用的线程将被阻塞，直到被join()方法加入的线程执行完成之后它才会继续运行。

@SpringBootTest
//定义EmergencyThread类，实现Runnable接口
class EmergencyThread implements Runnable{
    //实现接口中的run()方法
    @Override
    public void run() {
        for (int i = 1; i <6; i++) {
            System.out.println(Thread.currentThread().getName() + "输入：" + i);
                try {
                    Thread.sleep(500);//当前线程休眠500毫秒
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
        }
    }
}
public class Example {
    public static void main(String[] args) throws Exception{
        //创建线程
         Thread t = new Thread (new EmergencyThread(),"线程一");
         t.start();
        for (int i = 1; i < 6; i++) {
            System.out.println(Thread.currentThread().getName() +"输入："+ i);
            if (i ==2){
                t.join(); //调用join()方法
            }
            Thread.sleep(500); //当前线程休眠500毫秒
        }
    }
 }
 

运行结果：

 　　main线程中开启了一个线程t，两个线程的循环体中都调用了Thread的sleep(500)方法，以实现两个线程的交替执行。当main()线程中的循环变量为2时，调用t线程的join()方法，这时，t线程就会“插队”优先执行。从运行结果来看，当main线程输出2后，线程一就开始执行，直到线程一执行完毕，main线程才继续执行。