欢迎大家来到IT世界,在知识的湖畔探索吧!

大佬的理解-> JavaIO

1、setPriority(int newPriority)

更改线程的优先级；

优先级

注意

优先级高的线程并不一定就比优先级低的先获得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();

    }

欢迎大家来到IT世界,在知识的湖畔探索吧!

运行结果

欢迎大家来到IT世界,在知识的湖畔探索吧!子线程执行
--- 线程名---：线程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案例

欢迎大家来到IT世界,在知识的湖畔探索吧!//强制加入执行线程：必须要等调用了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()

测试线程是否处于活动那个状态；