Java多线程详解三 线程状态

常用方法

setPriority(int newPriority) 更改线程的优先级

static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休息（会抛出异常）

void join() 等待该线程终止（超车）

static vioid yield() 暂停当前正在执行的线程对象，并执行其他线程

void intreeupt（） 中断线程（建议不要用这个方法）

boolean isAlive() 测试线程是否处于活动状态

• 停止线程
• 线程休眠sleep
• 线程礼让 yield
• 中途加入 join
• 线程状态观测 priority
• 线程守护 daemon

停止线程

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

/*
    测试stop
    1. 建议线程正常停止-->利用次数，不建议死循环（死循环也要限制运行速度，防止cpu卡死）
    2.建议使用标志位-->设置一个标志位
    3.不要使用 stop 或者 destroy 等过时或者JDk不建议使用的方法
 */
public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag = true;
    //多线程方法
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread"+i++);
        }
    }
    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        //开启多线程
        TestStop ts = new TestStop();
        new Thread(ts).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i == 900){
                //3.调用stop方法切换标志位，让线程停止
                ts.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

 

线程休眠【sleep】

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

模拟延迟 

//模拟延迟
//特点：放大问题的发生性
try {
                    Thread.sleep(65);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

模拟倒计时

//模拟倒计时
 public static void tenDown() throws InterruptedException {
     int num = 10;
     while (true){
         Thread.sleep(1000);
         System.out.println(num--);
         if (num<=0){
             break;
         }
     }
 }

打印当前系统时间 

    //打印当前系统时间
    Date starTime = new Date(System.currentTimeMillis());   //获取系统当前时间
    while (true){
        try {
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(starTime));  //打印时间格式
             starTime = new Date(System.currentTimeMillis());   //更新系统当前时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程礼让【yield】

• 礼让线程，就是让当前正在运行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功！看cpu心情

//测试礼让线程
//礼让不一定成功
public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{

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

 

中途加入【Join】

• Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

//测试join方法，想象为插队
public class TestJoin implements Runnable{

    @Override
    public void run() {
        //子线程
        for (int i = 0; i < 300; i++) {
            System.out.println("线程VIP来了！！"+i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //启动线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 1000; i++) {
            if (i==400){
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

主线程和子线程并发随机运行，当i==400时，子线程强制运行， 待子线程运行完毕后，主线程才再起运行。

线程状态观测【State】
Thread.State

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

• NEW 尚未启动的线程处于此状态
• RUNNABLE 在Java虚拟机中执行的线程处于此状态
• BLOCKED 被阻塞等待监视器锁定的线程处于此状态
• WAITING 在等待另一个线程执行特定动作的线程处于此状态
• TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
• TERMINATED 已退出的线程处于此状态（死亡之后的线程就不能再启动了）
• 一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

public class TestState {
    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) {
                    e.printStackTrace();
                }
                System.out.println("主线程+/");
            }
        });
        //观察状态
        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);  //输出状态
        }
    }
}

 可以利用线程的状态进行一些操作，如：如果线程秒处于TIMED_WAITING长达30秒，可以让它强制崩溃。停止之后的线程，不能再次运行。

线程优先级【Priority】

• Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
• 线程的优先级用数字表示，范围从1~10
• Thread.MIN_PRIORITY = 1;
• Thread.MAX_PRIORITY = 10;
• Thread.NORM_PRIORITY = 5;
• 使用以下方式改变或获取优先级
• getPriority().setPriority(int xxx)

//测试线程优先级
public class TestPriority {
    public static void main(String[] args) {
        //主线程优先级打印
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        //设置6中优先级别
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);
		
        t1.start();     //子程序默认优先级
        
		//先设置优先级，再设置启动
        
        t2.setPriority(Thread.MAX_PRIORITY);    //MAX_PRIORITY最高级10
        t2.start();

        t3.setPriority(1);
        t3.start();

        t4.setPriority(3);
        t4.start();

        t5.setPriority(6);
        t5.start();

        t6.setPriority(8);
        t6.start();
    }
}
class MyPriority implements Runnable{
    //子线程优先级打印
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

 结果:

main-->5
Thread-1-->10
Thread-5-->8
Thread-0-->5
Thread-4-->6
Thread-3-->3
Thread-2-->1

结果Thread-0和Thread-4证明，优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用，这都是看CPU的调度（性能倒置）

守护线程【Daemon】

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如，后代记录操作日志，监控内存，垃圾回收等待…
   

 

//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread thread = new Thread(god);
        thread.setDaemon(true);     //默认是false表示是用户线程，正常线路都是用户线程

        //启动
        thread.start();
        new Thread(you).start();

    }
}
//...
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("无量天尊");
        }
    }
}
//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <36000; i++) {
            System.out.println("快乐生活每一天！"+i);
        }
        System.out.println("=====goodbye!World!=====");
    }
}