05线程状态

线程状态

五大状态

线程方法

线程停止

• 不推荐JDK提供的stop()，destroy()方法[已废弃]
• 推荐线程自己停下来
• 建议使用一个标志位进行终止变量，当flag=false式，则终止线程运行

package edu.wzw.Thread;

public class termination implements Runnable{
    private Boolean flag=true;
    @Override
    public void run() {
         int j=0;
        while(flag){
            System.out.println("我在走线程++++++++"+j++);
        }
    }//设置一个公开的的方法停止线程，设置标志位
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        termination termination1 = new termination();

        new Thread(termination1).start();
        for (int i = 0; i < 100; i++) {
            System.out.println("走"+i);
            if (i==50){
                termination1.stop();
                System.out.println("线程停止了");
            }
        }

    }
}

线程休眠

• sleep（时间）指定当前线程阻塞的毫秒数
• sleep存在异常InterruptedException
• sleep时间达到后线程进入就绪状态
• sleep可以模拟网络延迟，倒计时等
• 每一个对象都有一个锁，sleep不会释放锁

//模拟网络延迟一秒
try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

模拟倒计时

package edu.wzw.Thread;

public class Countdown {
    public static void main(String[] args) throws InterruptedException {
//        Countdown countdown = new Countdown();
        for (int i = 10; i >=0; i--) {
            System.out.println(i);
            Thread.sleep(1000);
        }

    }
//    public void Count() throws InterruptedException {
//        Thread.sleep(1000);
//    }
}

//打印系统时间

package edu.wzw.Thread;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Countdown {
    public static void main(String[] args) throws InterruptedException {
        Date data = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true) {
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(data));
            data = new Date(System.currentTimeMillis());//更新时间
        }
    }
}

线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功！看cpu心情
• 礼让只是当前线程释放了cpu资源，和其他就绪线程一起重新竞争cpu资源。按照优先级高低获得资源，同级则随机

package edu.wzw.Thread;

public class Yielddemo01 {
    public static void main(String[] args) {
        Yieldtest yieldtest = new Yieldtest();
        new Thread(yieldtest,"a").start();
        new Thread(yieldtest,"b").start();
    }
}
class Yieldtest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"停止执行");
    }
}

线程强制执行

Join

• Join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
• 可以想象成插队，先执行

package edu.wzw.Thread;
public class JoinTest 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 {
        JoinTest joinTest = new JoinTest();
//        new Thread(joinTest).start();
        Thread thread=new Thread(joinTest);
        
        for (int i = 0; i < 500; i++) {
            if(i==200){
                thread.start();
                thread.join();//插队
            }
            System.out.println("普通"+i);
        }

    }
}

观测线程状态

• 线程状态。线程可以处于以下状态之一：

  • NEW
    尚未启动的线程处于此状态。
  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    已退出的线程处于此状态。

  一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

package edu.wzw.Thread;

public class StateTest implements Runnable {
    public static void main(String[] args) throws InterruptedException {
        StateTest stateTest = new StateTest();
        Thread thread = new Thread(stateTest);
        //观察状态
        Thread.State state=thread.getState();
        System.out.println(state);//new
        //观察启动后
        thread.start();
        state=thread.getState();
        System.out.println(state);//run

        while(state!=Thread.State.TERMINATED){
            Thread.sleep(100);
            state=thread.getState();
            System.out.println(state);
        }
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }System.out.println("完成");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WsF4QSgy-1624717280833)(C:\Users\deku\AppData\Roaming\Typora\typora-user-images\image-20210619145710089.png)]

Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }System.out.println("完成");
}

}

[外链图片转存中...(img-WsF4QSgy-1624717280833)]

输出可能会出现这样的情况：很好理解，当最后一次while循环，进入循环体的时候state还不是终止状态，再循环体内部更新状态后才是终止状态，所以TERMINATED可以输出来