【Java开发】JUC基础 03：线程五大状态和主要方法

news2024/11/14 3:16:08

1 概念介绍

📌 五大状态：

new：Thread t = new Thread(); 线程对象一旦被创建就进入到了新生状态；

就绪状态：当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行；

运行状态：进入运行状态，线程才真正执行线程体的代码块；

阻塞状态：当调用sleep，wait或同步锁定时，线程进入阻塞状态，此时代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行；

dead：线程中断或结束，一旦进入死亡状态，就不能再次启动。

如下图：

📌 主要方法：

setPriority()：改变线程的优先级，让cpu有个参考的执行顺序。

// 数字大小范围 1~10
new Thread(new A()).setPriority(4)

static void sleep()：让当前线程睡眠一定时间，睡眠会让线程进入阻塞状态，时间到达后重新进入就绪状态；每个对象都有一把锁，sleep不释放锁；

void join()：插队，将某一个线程强行插队，其它线程被阻塞需要等待这个线程去完成后，才有资格继续工作

new Thread(new A()).join()

static void yield()：礼让。暂停下当前的线程，不阻塞，让cpu重新执行一个调度工作，等于是多线程们，重新再出发！

void interrupt()：中止线程，现在不考虑用这个方法了，更多考虑用标志位的方法去中止线程

boolean isAlive()：查看线程是否处于活动状态

getState()：获得某个线程的状态（NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED）

2 线程方法实践

2.1 线程状态

通过state方法可以观察线程的状态

public class MyThreadState {

    public static void main(String[] args) throws InterruptedException {

        //使用lambda表达式
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("///");
        });

        Thread.State state = thread.getState();
        System.out.println("线程创建未启动时状态:"+state);

        thread.start();
        state = thread.getState();
        System.out.println("线程启动后的状态:"+state);

        while (state != Thread.State.TERMINATED){
            System.out.println("线程运行时状态:"+state);
            Thread.sleep(800);
            state = thread.getState();
        }

        state = thread.getState();
        System.out.println("线程结束状态："+state);
    }
}

控制台输出：

📢 能够清楚地看到各状态情况，该线程每次睡眠1秒钟，第四秒时这个空挡还是运行状态。

2.2 线程停止

📌 要点

建议线程正常停止; -> 一般是利用次数，不建议死循环

建议使用标志位；

不建议使用 stop 和 destroy 方法，已过时

public class MyThreadStop implements Runnable{

    //1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int j = 0;
        while (flag){
            System.out.println(Thread.currentThread().getName()+""+j++);
        }
    }

    //2.设置一个公开的方法停止线程
    public void myStop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        MyThreadStop myThreadStop = new MyThreadStop();
        new Thread(myThreadStop,"MyThreadStop").start();

        for (int i = 0; i < 50; i++) {
            System.out.println("main"+i);
            if (i == 30){
                //3.调用自定义的 myStop方法切换标志位，让线程停止
                myThreadStop.myStop();
                System.out.println("该线程已停止");
            }
        }
    }
}

控制台输出：

📢 注意，MyThreadStop线程是在main线程输出到main30时停止的，说明停止成功。至于，MyThreadStop能输出到多少，得看cpu的执行或分配。

2.3 线程插队

用到join()方法，优先执行--插队

public class MyThreaJoin {

    public static void main(String[] args) {
        //使用lambda表达式
        Thread thread = new Thread(()->{
            for (int i = 0; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName()+"vip线程开始跑！"+i);
            }
        });
        thread.start();

        for (int i = 0; i <= 10; i++) {
            if (i == 3){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+i+"正在跑！");
        }

    }
}

控制台输出：

📢 我这台电脑是main线程跑得快，可以看到A线程插队到了main3之前，这就是join()方法的作用

2.3 线程优先级

📌 要点

SetPriority (int i )：设置线程优先级

GetPriority () ：获取线程的优先级

三个优先级常量： Thread.MIN_PRIORITY = 1; thread.MAX_PRIORITY = 10; thread.NORM_PRIORITY = 5

public class MyThreadPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"的优先级"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);

        //先设置优先级，再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();

        t4.setPriority(4);
        t4.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"的优先级"+Thread.currentThread().getPriority());
    }
}

控制台输出：

📢 可以看到优先级默认是5，同时线程并不是严格按照优先级的顺序启动，这是因为优先级高只是提高了cpu调度的概率，具体还得看cpu。

2.4 守护线程

📌 要点

线程分为用户线程和守护线程；

虚拟机必须确保用户线程执行完；

虚拟机不必等待守护线程执行完毕；

如：后台记录日志，监控内存，垃圾回收线程等都是守护线程。

public class MyThreadDaemon {

    public static void main(String[] args) {
        You you = new You();
        God god = new God();

        Thread youThread = new Thread(you);
        Thread godThread = new Thread(god);

        godThread.setDaemon(true);//默认是false表示是用户现场，正常的线程都是用户现场
        youThread.start();
        godThread.start();
    }
}

//上帝，守护线程
class God implements Runnable{
    @Override
    public void run() {
        long l = 0;
        while (true){
            System.out.println("上帝保佑你！"+l++);
        }
    }
}

//you 用户线程
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("每天都在健康的活着"+i);
        }
        System.out.println("you goodBye world!");
    }
}

控制台输出：