大佬的理解-> 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

线程休眠

//休眠一秒Thread.sleep(1000); //单位毫秒//TimeUnit.MILLISECONDS.sleep(1000); //单位毫秒//TimeUnit.SECONDS.sleep(1); //单位毫秒

强制加入子线程，谁调用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---主线程执行结束---

线程礼让：提供一种礼让的可能，但是不能保证绝对礼让，是一个概率事件（可能让，可能不让）；

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()

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