多线程之线程状态

逃离我推掉我的手 2022-10-09 06:18 266阅读 0赞

***\#\# 线程状态  
五大状态***

> 1.创建状态：Thread thread = new Thread(); 线程对象一旦创建就进入了新生状态。  
> 2.就绪状态：当调用start()方法时，进入就绪状态，但不代表立即调度执行（等待cpu调度）。  
> 3.运行状态或同态：进入运行状态，线程才真正执行线程体的代码块。  
> 4. 阻塞状态：当调用sleep,wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞解除后进入就绪状态，等待cpu调度。  
> 5.死亡状态：线程中断或者结束，进入死亡状态，不能再次启动。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxOTkzOTMz_size_16_color_FFFFFF_t_70_pic_center]  
**停止线程**

> 停止线程：不推荐使用jdk的方法(已废弃)，建议使用一个标志位进行终止变量，当fiag=false时，则终止线程进行。

**示例代码：**

//测试stop    线程停止
    
    //1.建议线程正常停止--->利用次数，不建议死循环
    //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 testStop = new TestStop();
            new Thread(testStop).start();
    
            for (int i = 0; i < 1000; i++) {
        
                System.out.println("main" + i);
                if (i == 900) {
        
                    //调用自己的stop方法切换标志位，停止线程
                    testStop.stop();
                    System.out.println("线程停止了");
                }
            }
        }
    }

**线程休眠**

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

**示例代码：**

//模拟网络延迟：放大问题的发生性      线程休眠
    
    public class TestSleep01 implements Runnable{
        
        //票数
        private int ticketNums = 10;
        @Override
        public void run() {
        
            while (true) {
        
                if (ticketNums <= 0) {
        
                    break;
                }
                //模拟延时
                try {
        
                    Thread.sleep(200);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
            }
        }
        public static void main(String[] args) {
        
            TestSleep01 ticket = new TestSleep01();
            new Thread(ticket,"小唐").start();
            new Thread(ticket,"小吴").start();
            new Thread(ticket,"小李").start();
        }
    }

**线程礼让**

> 礼让线程，让当前正在执行的线程暂停，但不堵塞  
> 将线程从运行状态转为就绪状态  
> 让CPU重新调度，礼让不一定成功！看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方法     想象为插队
    public class TestJoin implements Runnable{
        
        @Override
        public void run() {
        
            for (int i = 0; i < 100; 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 < 500; i++) {
        
                System.out.println("主线程"+i);
                if (i==200){
        
                    thread.join();//插队
                }
            }
        }
    }

**观测线程的状态**

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

**示例代码：**

//观察测试线程的状态
    
    public class TestState {
        
        public static void main(String[] args) throws InterruptedException {
        
            //Lamdba表达式
            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();//getState()获得线程状态
            System.out.println(state);//NEW
    
            //观察启动后
            thread.start();//启动线程
            state = thread.getState();
            System.out.println(state);//RUNNABLE
    
            while (state != Thread.State.TERMINATED) {
        //只要线程不中止，就一直输出状态，直到线程为退出状态
                Thread.sleep(100);
                state = thread.getState();//更新线程状态
                System.out.println(state);//输出状态
            }
    
        }
    }

**线程的优先级**

> 线程拥有优先级（从1-10）
> 
>     通过阅读Thread的源码可以得知：
>     
>         线程最小的优先值为1，最大为10，若没有设置则默认为5
>     
>         优先级设置若小于1或者大于10，则会抛出异常！
>     
>         可以通过set/getPriority来设置获取优先级

**示例代码：**

//测试线程的优先级
    public class TestPriority {
        
        public static void main(String[] args) {
        
            //主线程默认优先级
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
            Priority p = new Priority();
            Thread t1 = new Thread(p);
            Thread t2 = new Thread(p);
            Thread t3 = new Thread(p);
            Thread t4 = new Thread(p);
    
            //先设置优先级再启动
            t1.setPriority(3);
            t1.start();
            t2.setPriority(Thread.MAX_PRIORITY);//10
            t2.start();
            t3.start();//默认优先级为5
            t4.setPriority(Thread.MIN_PRIORITY);//1
            t4.start();
        }
    }
    class Priority implements Runnable{
        
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        }
    }

注意点：  
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用，主要还是看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 < 36500; i++) {
        
                System.out.println("你每一天都在开心得活着");
            }
            System.out.println("====goodbye world!======");
        }
    }
    /*
    God线程本应无限循环，但是设置成了守护线程，
    守护线程在用户线程执行完后就会结束！*/

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxOTkzOTMz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/b06d258d88894b02b7513f6f1491f377.png