多线程(三)-线程调度
大佬的理解-> JavaIO
setPriority(int newPriority) | 更改线程的优先级 |
---|---|
static void sleep(long millis) | 让当前正在执行的线程在指定的毫秒数内休眠 |
join() | 等待该线程终止(插队) |
static void yield() | 暂停当前正在执行的线程对象,并执行其他线程(礼让 |
interript() | 中断线程 |
isAlive() | 测试线程是否处于活动那个状态 |
1、setPriority(int newPriority)
更改线程的优先级;
优先级
取值范围 | [1,10] 值越小,优先级越小 |
---|---|
MAX_PRIORITY = 10; | 最大优先级10 |
NORM_PRIORITY = 5; | 默认优先级5 |
MIN_PRIORITY = 1; | 最小优先级1 |
注意
优先级高的线程并不一定就比优先级低的先获得cpu资源,只是获得cpu资源的概率比较大,具体还要看cpu的调度算法;
设置优先级案例
public class MyThreadPriority implements Runnable{
@Override
public void run() {
//线程执行的业务方法
System.out.println("子线程执行");
for (int i = 0;i < 5;i++){
System.out.println("--- 线程名---:"+Thread.currentThread().getName()+",序号:"+i);
}
}
public static void main(String[] args) {
//创建线程并设置线程名和优先级
Thread thread1 = new Thread(new MyThreadPriority(),"线程A");
Thread thread2 = new Thread(new MyThreadPriority(),"线程B");
//线程优先级的取值范围:[1,10],默认是5,值越小,优先级越小
//设置线程优先级,只能代表优先级高的线程获取cpu资源的概率较大,单不是绝对优先,它取决于cpu的调度算法
thread1.setPriority(Thread.MAX_PRIORITY);
thread2.setPriority(Thread.MIN_PRIORITY);
//启动线程
thread1.start();
thread2.start();
}
运行结果
子线程执行
--- 线程名---:线程A,序号:0
--- 线程名---:线程B,序号:0
--- 线程名---:线程A,序号:1
--- 线程名---:线程A,序号:2
--- 线程名---:线程A,序号:3
--- 线程名---:线程A,序号:4
--- 线程名---:线程B,序号:1
--- 线程名---:线程B,序号:2
--- 线程名---:线程B,序号:3
--- 线程名---:线程B,序号:4
2、 sleep(long millis)
线程休眠
//休眠一秒
Thread.sleep(1000); //单位毫秒
//TimeUnit.MILLISECONDS.sleep(1000); //单位毫秒
//TimeUnit.SECONDS.sleep(1); //单位毫秒
3、join()
强制加入子线程,谁调用join的方法,谁加入,当前线程会暂停,等待加入的子线程运行结束才可以继续执行;
join案例
//强制加入执行线程:必须要等调用了join方法的线程执行结束,必然发生
public class MyThreadJoin implements Runnable{
@Override
public void run() {
//线程执行的业务方法
System.out.println("子线程执行");
for (int i = 0;i < 3;i++){
System.out.println("--- 线程名---:"+Thread.currentThread().getName()+",序号:"+i);
try {
//休眠一秒
// Thread.sleep(1000);
// TimeUnit.MILLISECONDS.sleep(1000);
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
//创建一个子线程对象
Thread thread = new Thread(new MyThreadJoin(), "强制Join线程");
//启动子线程
thread.start();
//主线程
System.out.println("***主线程执行***");
System.out.println("***线程名***:"+Thread.currentThread().getName());
try {
System.out.println("---主线程中强制加入子线程,继续执行---");
//强制加入子线程,谁调用join的方法,谁加入,当前线程会暂停,等待加入的子线程运行结束才可以继续执行;
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---主线程执行结束---");
}
}
运行结果
***主线程执行***
子线程执行
***线程名***:main
---主线程中强制加入子线程,继续执行--- //子线程join后主线程要等子线程执行完成才可以继续执行
--- 线程名---:强制Join线程,序号:0
--- 线程名---:强制Join线程,序号:1
--- 线程名---:强制Join线程,序号:2
---主线程执行结束---
4、yield()
线程礼让:提供一种礼让的可能,但是不能保证绝对礼让,是一个概率事件(可能让,可能不让);
yield案例
//线程礼让:提供一种礼让的可能,但是不能保证绝对礼让,是一个概率事件
public class MyThreadYield implements Runnable{
@Override
public void run() {
//线程执行的业务方法
System.out.println("子线程执行");
for (int i = 0;i < 10;i++){
System.out.println("--- 线程名---:"+Thread.currentThread().getName()+",序号:"+i);
//当执行到第6次,执行礼让
if(i ==5){
System.out.println("==="+Thread.currentThread().getName()+"礼让===");
Thread.yield();
//静态方法,通过线程对象调用
}
}
}
public static void main(String[] args) {
MyThreadYield myThreadYield = new MyThreadYield();
//创建子线程并启动
new Thread(myThreadYield,"线程1").start();
new Thread(myThreadYield,"线程2").start();
new Thread(myThreadYield,"线程3").start();
}
}
运行结果
子线程执行
子线程执行
子线程执行
--- 线程名---:线程1,序号:0
--- 线程名---:线程2,序号:0
--- 线程名---:线程1,序号:1
--- 线程名---:线程3,序号:0
--- 线程名---:线程1,序号:2
--- 线程名---:线程2,序号:1
--- 线程名---:线程1,序号:3
--- 线程名---:线程3,序号:1
===线程1礼让===
--- 线程名---:线程2,序号:2 //线程3变成了线程2,礼让了
--- 线程名---:线程1,序号:4
--- 线程名---:线程3,序号:2
--- 线程名---:线程1,序号:5
--- 线程名---:线程2,序号:3
--- 线程名---:线程1,序号:6
--- 线程名---:线程3,序号:3
--- 线程名---:线程1,序号:7
===线程2礼让===
--- 线程名---:线程1,序号:8 //还是线程1,没有发生礼让
===线程3礼让===
--- 线程名---:线程1,序号:9 //还是线程1,没有发生礼让
--- 线程名---:线程2,序号:4
--- 线程名---:线程3,序号:4
--- 线程名---:线程2,序号:5
--- 线程名---:线程3,序号:5
--- 线程名---:线程2,序号:6
--- 线程名---:线程3,序号:6
--- 线程名---:线程2,序号:7
--- 线程名---:线程3,序号:7
--- 线程名---:线程2,序号:8
--- 线程名---:线程3,序号:8
--- 线程名---:线程2,序号:9
--- 线程名---:线程3,序号:9
所以线程礼让是一种概率事件;
5、interript()
线程中断;
6、isAlive()
测试线程是否处于活动那个状态;