线程状态

线程状态有以下五类

线程方法

• setPriority(int newPriority) 设置线程的优先级
• static void sleep(long millis) 在指定毫秒数内让当前正在执行的线程休眠
• void join() 等待该线程停止
• static void yield() 暂定当前正在执行的线程对象，并执行其他线程
• boolen isAlive() 测试线程是否处于活跃状态

线程停止

不推荐使用jdk提供的stop或distory来停止线程，推荐让线程自己停下来，建议使用一个flag标志位来判定，flag=false线程停止

public class SafeThreadStopExample {
    // 定义线程停止的标志位（必须用volatile保证可见性）
    private static volatile boolean stopFlag = false;

    public static void main(String[] args) throws InterruptedException {
        // 创建线程, 匿名实现runnable接口
        Thread workerThread = new Thread(() -> {
            int count = 0;
            // 循环判断标志位，决定是否继续运行
            while (!stopFlag) {
                System.out.println("线程运行中，计数：" + count++);
                try {
                    // 模拟线程执行任务的耗时
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // 捕获中断异常后可以做收尾工作，也可以选择重新设置中断状态
                    System.out.println("线程被中断，准备停止");
                    // 可在此处手动设置标志位为true，确保线程停止
                    stopFlag = true;
                }
            }
            // 线程停止前的收尾工作
            System.out.println("线程已安全停止，最终计数：" + count);
        });

        // 启动线程
        workerThread.start();

        // 主线程休眠3秒后，设置标志位让子线程停止
        Thread.sleep(3000);
        stopFlag = true;
        System.out.println("主线程已设置停止标志，等待子线程停止...");

        // 等待子线程执行完毕
        workerThread.join();
        System.out.println("程序执行结束");
    }
}

为什么不推荐stop()/destroy()：

1. stop()会强制终止线程，可能导致线程持有的资源（如锁）无法释放，引发数据不一致。
2. destroy()是未实现的方法，直接调用会抛出异常，且同样不安全。(已废弃)

线程休眠

• 执行sleep后线程进入阻塞状态
• sleep存在异常InterruptedExpection
• sleep等待完成后进入就绪状态(阻塞不能直接到运行态)
• sleep可以模拟网络延时，用于制作计数器等
• 每个对象都会上锁，sleep不会释放锁

计数器程序参考上一个程序

线程礼让-yield

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        Thread t1 = new Thread(myYield, "t1");
        Thread t2 = new Thread(myYield, "t2");
        t1.start();
        t2.start();
    }
}

class MyYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行...");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"结束执行...");
    }
}

合并线程(插队)

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("thread "+Thread.currentThread().getName()+i+" run...");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new TestJoin(), "t");
        t1.start();

        for (int i = 0; i < 1000; i++) {
            if (i == 200) {
                t1.join();
            }
            System.out.println("thread "+Thread.currentThread().getName()+i+" run...");
        }
    }
}

线程状态

public enum State {
        // 尚未启动的线程 new完对象进入
        NEW,  
        // Jvm 中执行的线程 就绪状态
        RUNNABLE,
        // 被阻塞等待监听器锁定的线程 
        BLOCKED,
        // 正在等待另一个线程执行特定动作的线程
        WAITING,
        // 正在等待另一个线程执行特定动作到达指定等待时间的线程
        TIMED_WAITING,
        // 已退出的线程
        TERMINATED;
}

死亡的线程不可以在进行start操作，如下:

public class ThreadStatus {
    // 观测线程状态
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("Thread is running");
        });
        // 观测状态
        Thread.State state = thread.getState();
        System.out.println("Thread state is " + state);
        // 运行
        thread.start();
        state = thread.getState();
        System.out.println("Thread state is " + state);
        while (state != Thread.State.TERMINATED) {  // 线程不终止， 一直输出状态
            Thread.sleep(100);
            state = thread.getState();  // 更新状态
            System.out.println("Thread state is " + state);
        }
        // 这里运行将会报错，因为线程已经死亡
        // thread.start() 
    }
}