多线程常见的成员变量及生命周期

方法名	说明
String getName()	返回次现场名称
void setName(String name)	设置线程名称（构造方法也可以设置名字）
static Thread currentThread()	获取当前线程对象
static void sleep(long time)	让线程休眠指定的时间，单位为毫秒
setPriority(int new Priority)	设置线程优先级
final int getPriority()	获取线程优先级
final void setDaemon (boolean on )	设置守护线程
public static void yield()	出让线程/礼让线程
public static void join()	插入线程/插队线程

获取线程及名称、休眠：

package com.ruoyi.web.controller.thread;

import java.util.Date;

/**
 * 多线程四种处理方式 -- 第一种 继承Thread类 重写run方法
 *
 * @author zhuang.bq
 * @create 2024/5/13  9:13
 * @desc
 **/
public class MyThread1 extends Thread {

    public MyThread1() {
    }

    public MyThread1(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            String threadName = MyThread1.currentThread().getName();
            System.out.println(threadName +"@"+ i+".start");
        }
    }

    public static void main(String[] args) {
        /**
         * String getName()	返回次现场名称
         * void setName(String name) 	设置线程名称（构造方法也可以设置名字）
         *      1.若开发者未给线程设置名字，线程也是有默认名字的 格式：Thread-X(X序号，从0开始）
         *      2.可以 通过setName或者构造方法来设置名称
         * static Thread currentThread()	获取当前线程对象
         *      ·当JVM虚拟机启动后，会自动启动多条线程，其中有一条线程叫main线程
         *      ·他的作用就是调用main方法，并执行里面的代码
         *      ·所以我们之前写的所有代码都是运行在main线程当中
         * static void sleep(long time)	让线程休眠指定的时间，单位为毫秒
         *      ·哪条线程执行到这个方法，哪条线程就会在这里停留对应的时间
         *      ·方法的参数就是睡眠的时间，单位为毫秒 1s=1000ms
         *      ·当时间到了之后，线程会自动醒来并继续执行下面的方法
         */
//        MyThread1 t1 = new MyThread1("线程1");
//        MyThread1 t2 = new MyThread1("线程2");
//        t1.start();
//        t2.start();
        //哪条线程执行到这个方法，此时获取的就是哪条线程的对象
        Thread t = Thread.currentThread();
        System.out.println(t.getName());
        
        
    }
}

优先级描述

        线程的调度：

                1.抢占式调度：多个线程 在抢占CPU的执行权，CPU无法知道他执行哪条线程与执行的时间无法确定。抢占式调度体现了随机行，java中一般使用这种方式。

                2.非抢占式调度：所有的线程轮流执行。

        优先级：

                1.java中一般使用抢占式调度，所以设置的优先级越大，该线程抢占到CPU的概率越大，java中优先等级（1低->10高）10档。若未设置，则为5。

package com.ruoyi.web.controller.thread;

/**
 * 实现runnable接口方式实现
 *
 * @author zhuang.bq
 * @create 2024/5/13  15:57
 * @desc
 **/
public class MyRun1 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName+"_" +i+ ".run");
        }
    }

    public static void main(String[] args) {
        MyRun1 myRun1 = new MyRun1();//创建run对象 表示需要执行的任务
        Thread t1 = new Thread(myRun1,"飞机");//创建线程对象，并将自定义线程丢进去
        Thread t2 = new Thread(myRun1,"火车");

        System.out.println(t1.getPriority());//查看默认优先级 默认为5
        System.out.println(t2.getPriority());
        System.out.println(Thread.currentThread().getPriority());//查看默认优先级 main线程 默认为5
        t1.setPriority(1);//修改优先级（1低->10高） 通常情况下 优先级越高 抢占到CPU的概率越高，概率问题 无法保证一定
        t2.setPriority(10);
        t1.start();//开启线程
        t2.start();

    }


}

守护线程

package com.ruoyi.web.controller.thread;

/**
 * @author zhuang.bq
 * @create 2024/5/16  14:53
 * @desc
 **/
public class MyThread2 extends Thread{
    public MyThread2() {
    }

    public MyThread2(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() +"@"+ i+".start");
        }
    }
}

package com.ruoyi.web.controller.thread;

/**
 * @author zhuang.bq
 * @create 2024/5/16  14:53
 * @desc
 **/
public class MyThread3 extends Thread{
    public MyThread3() {
    }

    public MyThread3(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(getName() +"@"+ i+".start");
        }
    }
}

package com.ruoyi.web.controller.thread;

/**
 * @author zhuang.bq
 * @create 2024/5/16  15:41
 * @desc
 **/
public class ThreadTest {

    /**
     * final void setDaemon (boolean on )	设置守护线程
     *  `当其他的非守护线程执行完毕之后，守护线程会陆续结束
     *      也就是说 当非守护线程结束了，守护线程也就没有存在的必要了
     *      非守护线程会跑完所有逻辑，而守护线程不会跑完所有的逻辑  守护线程是陆续结束 而不是马上结束
     *
     * @param args
     */
    public static void main(String[] args) {
        MyThread2 t2 = new MyThread2("女神");//非守护线程
        MyThread3 t3 = new MyThread3("备胎");//守护线程
        t3.setDaemon(true);//将第三个线程设置为守护线程（备胎线程）
        t2.start();
        t3.start();
    }
}

执行结果如下：

应用场景：

出让线程、礼让线程

package com.ruoyi.web.controller.thread;

/**
 * @author zhuang.bq
 * @create 2024/5/16  14:53
 * @desc
 **/
public class MyThread4 extends Thread{
    public MyThread4() {
    }

    public MyThread4(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() +"@"+ i+".start");
            Thread.yield();//表示出让当前CPU的执行权 尽可能的让结果均匀一点
        }
    }

    /**
     * public static void yield()	出让线程/礼让线程
     * @param args
     */
    public static void main(String[] args) {
        MyThread4 t1 = new MyThread4("飞机");
        MyThread4 t2 = new MyThread4("火车");
        t1.start();
        t2.start();
    }
}

插入线程/插队线程

package com.ruoyi.web.controller.thread;

/**
 * @author zhuang.bq
 * @create 2024/5/16  14:53
 * @desc
 **/
public class MyThread5 extends Thread{
    public MyThread5() {
    }

    public MyThread5(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() +"@"+ i+".start");
        }
    }

    /**
     * public static void yield()	出让线程/礼让线程
     * @param args
     */
    public static void main(String[] args) throws InterruptedException {
        MyThread5 t1 = new MyThread5("包子");
        t1.start();
        //将t1这个线程 插入到当前线程之前
        //t1:包子
        //当前线程：main线程
        t1.join();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程:"+i);
        }
    }
}

线程生命周期