多线程—线程状态

线程状态

线程停止stop

​ 1.JDK中自带的stop方法和destroy方法（已废弃不推荐使用）

​ 2.让线程自己停止下来

​ 3.使用一个标志位进行终止变量，来控制线程的运行，代码案例如下：

public class ThreadStop implements Runnable{

    //设置一个标志来控制线程
    private boolean flag = true;

    //设置一个公开的方法来停止线程，改变标志
    public void stop() {
        this.flag = false;
    }

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

    public static void main(String[] args) {
        ThreadStop threadStop = new ThreadStop();

        new Thread(threadStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if(i == 900){//主线程和刚刚创建的线程同时运行，刚刚创建的线程在运行run方法第900次的时候停止，主线程依旧继续运行
                //调用stop（非jdk里面的）方法,改变标志，让线程停止
                threadStop.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

线程休眠sleep

1.sleep(时间)指定当前线程阻塞的毫秒数

2.sleep存在异常InterruptedException，所以要try-catch

3.sleep时间达到之后，线程进入就绪状态

4.sleep可以模拟网络延时，倒计时等

5.每个对象都有一个锁，sleep不会释放锁

//模拟倒计时
public class ThreadSleep {

    public static void main(String[] args) {
        try{
            tenDown();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            //模拟1s线程运行一次
            Thread.sleep(1000);
            System.out.println(num--);
            if(num <= 0){
                break;
            }
        }

    }
}

线程礼让yield

1.礼让线程，让当前线程正在执行的线程暂停，但不阻塞。

2.将线程从运行状态转为就绪状态。

3.让cpu重新调度，礼让不一定成功。

public class ThreadYield {
}
class MyYield implements Runnable{

    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

线程强制执行join

join方法合并线程，其他线程阻塞，待线程执行完之后，再执行其他线程。

public class ThreadJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程vip来了" + i);
        }
    }

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

        //启动线程
        ThreadJoin threadJoin = new ThreadJoin();
        Thread thread = new Thread(threadJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if(i == 200){
                //刚刚开始是两个线程同时执行，当主线程运行到200之后，thread线程将插队，则后面的都是thread线程在运行
                thread.join();//插队
            }
            System.out.println("main" + i);
        }
    }
}

线程状态观测

共5个状态：

新生NEW —> 就绪WAITING —> 运行RUNNABLE —> 阻塞(BLOCKED和TIMED_WAITING) —>死亡TERMINATED

1.NEW:未启动线程处于此状态

2.RUNNABLE:在java虚拟机中执行属于此状态

3.BLOCKED:在阻塞等待监视器锁定处于此状态

4.WAITING:正在等待另外一个线程执行特定动作处于此状态

5.TIMED_WAITING:正在等待另外一个线程执行动作达到指定等待时间处于此状态

6.TERMINATED：已退出线程处于此状态

//观测线程的状态
public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);//睡觉5s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");//等5s才会打印这一行
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//NEW

        //观察启动后
        thread.start();//启动线程，中断或者结束都不能再启动第二次了
        state = thread.getState();
        System.out.println(state);//Runnable

        while(state != Thread.State.TERMINATED){//只要线程还在睡眠，就一直输出
            thread.sleep(100);//每隔0.1s输出一次状态
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

运行结果如下：

​ …