1. 首页
  2. 文章中心
  3. Thread

java成神之路——线程的状态以、线程的方法、线程的优先级、守护线程

81 阅读 0 评论
我是靠谱客的博主 迷人红酒，最近开发中收集的这篇文章主要介绍java成神之路——线程的状态以、线程的方法、线程的优先级、守护线程，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

线程的五种状态

线程的状态有新生（new）、就绪、运行、堵塞、死亡（dead），下面用图来说明他们之间的联系
在这里插入图片描述
New：线程对象一旦创建就进入到新生状态 Thread t= new Thread()；
就绪：当调用start()方法，线程立即进入到就绪状态，但不意味着立即调度执行；
运行：进入运行状态，线程才真正执行线程体的代码块;
dead：线程中断或者结束，一旦进入死亡状态就不能再次启动
堵塞：当调用sleep、wait或同步锁定的时候，线程进入堵塞状态，就是代码不往下执行，堵塞事件解除后，重新进入就绪状态，等待cpu调度执行。

线程的方法

在这里插入图片描述

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

public class ThreadStop   implements  Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag) {
            try {
                Thread.sleep(100);

            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("运行------Thread"+ i++);

        }
    }
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadStop t = new ThreadStop();
        new Thread(t).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程"+i);
            if (i == 900){
                t.stop();
                System.out.println("该线程停止了");
            }

        }

    }
}
休眠线程
  • sleep(时间)指定当前线程阻塞的秒数
  • sleep存在异常InterruptedException
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延时器和到时器等
  • 每个对象都有一把锁，sleep不会释放锁
    其实休眠线程在前初始并发中模拟卖票的时候已经用到过了初始并发
    那这里我们就用休眠线程来模拟一个到时器，和每间隔一秒打印出系统时间
package thread;

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

public class TestSleep {

    public static void main(String[] args) {
    //十秒到时器
        tendown();
     // 每隔一秒打印系统时间
        Date date = new Date(System.currentTimeMillis());
        while (true){
            try{
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
                date = new Date(System.currentTimeMillis());
            }catch (InterruptedException e){
                e.printStackTrace();
            }

        }
    }
    public static void tendown(){
        int num = 10;
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(num--);
            }catch (InterruptedException e){
                e.printStackTrace();
            }if (num <= 0){
                break;
            }

        }
    }
}
线程礼让——yield
  • 礼让线程，让当前正在执行的线程暂停，但不堵塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功！看CPU心情
package thread;

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

    public static void main(String[] args) {
        ThreadYield testYild = new ThreadYield();
       new Thread(testYild,"a").start();
       new Thread(testYild,"b").start();
    }
}
线程强制执行——JOin
  • Join合并线程，待此线程执行完成后再执行其他线程，其他线程堵塞
  • 这里我们用插队来举例
package thread;

public class ThreaJoin 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{
        ThreaJoin threaJoin = new ThreaJoin();
        Thread thread = new Thread(threaJoin);
       thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("一般用户"+i+"排队");
            if (i==200){
                thread.join();
            }
        }

    }
}
观测线程的状态

线程的状态在本文开头已经说明，现在我们在程序中来观测他的状态

package thread;

public class ThradState {


    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("//");
        });
        Thread.State state = thread.getState();
        System.out.println(state);
        thread.start();
        state = thread.getState();
        System.out.println(state);
       while (state != Thread.State.TERMINATED){
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           state = thread.getState();
           System.out.println(state);
       }
    }
}

线程的优先级

  • java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调用哪个线程来执行。

  • 从源码中我们可以得知，线程的优先级用数字表示，范围从1-10
    * Thread.MIN_PRIORITY = 1;
    * Thread.MAx_PRIORITY = 10;
    * Thread.NORM_PRIORITY = 6;
    在这里插入图片描述

  • 使用以下方式改变或获取优先级
    * getPriprity().setPriority(int XXX)

注意：

  •  优先级低，只意味着获取调度的概率低，并不是优先级低的就不会被调用，这都是看CPU的调度
  • 优先级高代表权重高，比如100张彩票和1张彩票的中奖几率，所以优先级高的也不一定会被先调用，只是获得调度的概率要大一些
package thread;

public class TestPriority {
    public static void main(String[] args) {
        //主线程的优先级 默认
        System.out.println(Thread.currentThread().getName()+"的优先级是——>"+Thread.currentThread().getPriority());
        MyPriority priority = new MyPriority();
        Thread t = new Thread(priority);
        Thread t1 = new Thread(priority);
        Thread t2 = new Thread(priority);
        Thread t3 = new Thread(priority);
        Thread t4 = new Thread(priority);
        Thread t5 = new Thread(priority);
        Thread t6 = new Thread(priority);
        //设置优先级再启动
        t.start();

        t1.setPriority(1);
        t1.start();

        t2.setPriority(6);
        t2.start();

        t3.setPriority(3);
        t3.start();

        t4.setPriority(10);
        t4.start();

        t5.setPriority(8);
        t5.start();

        t6.setPriority(2);
        t6.start();

    }
}
class MyPriority implements  Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"的优先级是——>"+Thread.currentThread().getPriority());
    }
}

在这里插入图片描述

守护线程

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

在这里我们用代码来演示一下守护线程，就用上帝守护着我们活着的日子为列。

package thread;
//测试守护线程
//上帝守护你
public class TestDaemon {
    public static void main(String[] args) {
        You you = new You();
        God god = new God();

        Thread thread = new Thread(god);
        //这里让god变为守护线程
        thread.setDaemon(true);//默认是false，正常的线程都是用户线程为false
        thread.start();//按照我们的写法god是不会停止的，但是虚拟机不会等待守护线程god结束，只会当you结束便结束
      new Thread(you).start();

    }
}

//你
class  You implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你活了100年，都很开心");
        }
        System.out.println("goodbye---world");
    }
}

//上帝
class God implements  Runnable{

    //上帝是用生的，这里我们让他一直跑
    @Override
    public void run() {
        while(true){
            System.out.println("上帝守护着你");
        }
    }
}

在这里插入图片描述
这里程序在You结束后还会跑一段时间，那是虚拟机还没有反应过来You已经结束，等它反应过来了便会结束。

最后

以上就是迷人红酒为你收集整理的java成神之路——线程的状态以、线程的方法、线程的优先级、守护线程的全部内容，希望文章能够帮你解决java成神之路——线程的状态以、线程的方法、线程的优先级、守护线程所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(54)

相关文章

【Java多线程】创建线程、线程的生命周期——Thread类和Runnable接口一、线程与进程二、并发与并行三、线程调度四、创建线程五、Thread和Runnable的区别六、Thread类常用方法七、线程中断八、线程插队九、用户线程和守护线程十、线程的生命周期(状态)
【Java多线程】创建线程、线程的生命周期——Thread类和Runnable接口一、线程与进程二、并发与并行三、线程调度四、创建线程五、Thread和Runnable的区别六、Thread类常用方法七、线程中断八、线程插队九、用户线程和守护线程十、线程的生命周期(状态)
19丨Tomcat：中间件监控及常用计数器解析（上）19丨Java & C ++：代码级监控及常用计数器解析（上）
19丨Tomcat：中间件监控及常用计数器解析（上）19丨Java & C ++：代码级监控及常用计数器解析（上）
MySQL中的LEFT JOIN 和UNIONALL的联合使用一、基础知识 二、实战三、最终答案
MySQL中的LEFT JOIN 和UNIONALL的联合使用一、基础知识 二、实战三、最终答案
《C/C++ QT 多线程总结三》Qt多线程
《C/C++ QT 多线程总结三》Qt多线程
java成神之路——线程的状态以、线程的方法、线程的优先级、守护线程
java成神之路——线程的状态以、线程的方法、线程的优先级、守护线程
java Thread卡死 项目内存一直增长
java Thread卡死 项目内存一直增长
Java中的线程礼让（yield方法）
Java中的线程礼让（yield方法）
哇，union的优先级很高嘛
哇，union的优先级很高嘛

评论列表共有 0 条评论

立即
投稿
返回
顶部