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类的三个静态常量
1 @SpringBootTest2 //定义MaxPriority,实现Runnable接口
3 class MaxPriority implementsRunnable{4 //实现接口中的run()方法
5 @Override6 public voidrun() {7 for (int i = 0; i <5; i++) {8 System.out.println(Thread.currentThread().getName() + "正在输出!");9 }10 }11 }12 //定义MinPriority,实现Runnable接口
13 class MinPriority implementsRunnable{14 //实现接口中的run()方法
15 @Override16 public voidrun() {17 for (int i = 0; i <5; i++) {18 System.out.println(Thread.currentThread().getName() + "正在输出!");19 }20 }21 }22 public classExample {23 public static voidmain(String[] args) {24 //创建两个线程
25 Thread minPriority = new Thread(new MinPriority(),"优先级较低的线程");26 Thread maxPriority = new Thread(new MaxPriority(),"优先级较高的线程");27 //设置线程的优先级为1
28 minPriority.setPriority(1);29 //设置线程的优先级为10
30 maxPriority.setPriority(10);31 //开启两个线程
32 minPriority.start();33 maxPriority.start();34 }35 }
程序运行结果:
优先级较高的maxPriority线程会先运行,运行完毕后优先级较低的minPriority线程才开始运行。
线程休眠
如果希望人为地控制线程,使正在运行的线程暂停,将CPU让给别的线程,这时可以使用静态方法sleep(long millis)方法,该方法可以让当前正在运行的线程暂停一段时间,进入休眠等待状态。当前线程调用sleep(long millis)方法后,在指定时间(参数 millis)内是不会执行的,这样其它的线程就可以得到执行的机会了。
sleep(long millis)方法声明抛出InterruptedExcption异常,因此在调用该方法时应该捕获异常,或者声明抛出异常。
1 @SpringBootTest2 //定义SleepThread,实现Runnable接口
3 class SleepThread implementsRunnable{4 //实现接口中的run()方法
5 @Override6 public voidrun() {7 for (int i = 0; i <5; i++) {8 if (i == 3){9 try{10 Thread.sleep(2000);//当前线程休眠2秒
11 }catch(InterruptedException e){12 e.printStackTrace();13 }14 }15 System.out.println("线程一正在输出:" +i);16 try{17 Thread.sleep(500); //当前线程休眠500毫秒
18 }catch(Exception e){19 e.printStackTrace();20 }21 }22 }23 }24 public classExample {25 public static void main(String[] args) throwsException{26 //创建一个线程
27 new Thread(newSleepThread()).start();28 for (int i = 0; i < 10; i++) {29 if (i ==5){30 Thread.sleep(2000);//当前线程休眠2秒
31 }32 System.out.println("主线程正在输出:" +i);33 Thread.sleep(500); //当前线程休眠500毫秒
34 }35 }36 }
运行结果:
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()方法结束后,只有与当前线程优先级相同或者更高的线程才能获得执行机会。
1 @SpringBootTest2 //定义YieldThread,继承Thread类
3 classYieldThread extends Thread{4 //定义一个有参的构造方法
5 publicYieldThread(String name) {6 super(name);7 }8 public voidrun() {9 for (int i = 0; i <5; i++) {10 System.out.println(Thread.currentThread().getName() + "---" +i);11 if (i == 3) {12 System.out.println("线程让步:");13 Thread.yield();14 }15 }16 }17 }18 public classExample {19 public static voidmain(String[] args) throws Exception{20 //创建两个线程
21 Thread t1 = new YieldThread("线程A");22 Thread t2 = new YieldThread("线程B");23 //开启两个线程
24 t1.start();25 t2.start();26 }27 }
运行结果:
如图,当线程B输出3以后,会做出让步,线程A继续执行,同样,当线程A输出3后,也会做出让步,线程B继续执行。
线程插队
当在某个线程中调用其他线程的join()方法时,调用的线程将被阻塞,直到被join()方法加入的线程执行完成之后它才会继续运行。
1 @SpringBootTest2 //定义EmergencyThread类,实现Runnable接口
3 classEmergencyThread implements Runnable{4 //实现接口中的run()方法
5 @Override6 public voidrun() {7 for (int i = 1; i <6; i++) {8 System.out.println(Thread.currentThread().getName() + "输入:" +i);9 try{10 Thread.sleep(500);//当前线程休眠500毫秒
11 }catch(InterruptedException e){12 e.printStackTrace();13 }14 }15 }16 }17 public classExample {18 public static voidmain(String[] args) throws Exception{19 //创建线程
20 Thread t = new Thread (new EmergencyThread(),"线程一");21 t.start();22 for (int i = 1; i < 6; i++) {23 System.out.println(Thread.currentThread().getName() +"输入:"+i);24 if (i ==2){25 t.join(); //调用join()方法
26 }27 Thread.sleep(500); //当前线程休眠500毫秒
28 }29 }30 }31
运行结果:
main线程中开启了一个线程t,两个线程的循环体中都调用了Thread的sleep(500)方法,以实现两个线程的交替执行。当main()线程中的循环变量为2时,调用t线程的join()方法,这时,t线程就会“插队”优先执行。从运行结果来看,当main线程输出2后,线程一就开始执行,直到线程一执行完毕,main线程才继续执行。