线程的优先级、守护线程、礼让线程、插入线程、中断线程

Surpass余sheng军

已于 2023-08-01 00:46:34 修改

阅读量952

点赞数 2

分类专栏： JavaSE 文章标签： java jvm 开发语言

于 2023-03-29 23:04:27 首次发布

By Mr.Gao

本文链接：https://blog.csdn.net/weixin_53622554/article/details/129846564

版权

JavaSE 专栏收录该内容

56 篇文章 6 订阅

订阅专栏

一. 线程的优先级

在计算机当中，线程的调度有两种方式：

抢占式调度模型：多个线程它是在抢夺CPU的执行权，CPU在什么时候执行哪条线程是不确定的，执行多长时间也是不确定的，所以抢占式调度它体现了一个随机性。优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。
非抢占式调度 / 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片。那就是所有的线程轮流的执行，你一次我一次，你一次我一次，执行的时间也是差不多的。

在Java当中，它采取了第一种抢占式调度模型的方式。抢占式调度，重点掌握两个字随机性。
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的。
优先级越大，那么这条线程抢到CPU的概率就是最大的。
在Java当中线程的优先级分为十档，最小的是一，最大的是十，如果没有设置默认就是五。
优先级越高，只能保证它抢到CPU时间片的概率是最大的，但不能保证百分之百抢到CPU的执行权，它只是一个概率问题。
线程的执行它是随机性的。

package com.gch.d2_api;
/**
   线程任务类
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
        }
    }
}

package com.gch.d2_api;

public class ThreadDemo03 {
    public static void main(String[] args) {
        /*
              setPriority(int newPriority)   设置线程的优先级
              final int getPriority          获取线程的优先级
         */
        // 创建线程要执行的参数对象
        Runnable target = new MyRunnable();
        // 创建线程对象
        Thread t1 = new Thread(target,"飞机");
        Thread t2 = new Thread(target,"坦克");

        System.out.println(t1.getPriority()); // 5
        System.out.println(t2.getPriority()); // 5

        // 虚拟机自己创建的main线程的优先级,也是5
        System.out.println(Thread.currentThread().getPriority()); // 5


        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}

飞机的优先级为1，坦克的优先级为10，而飞机还先执行完！

二. 守护线程(备胎线程)

当唯一运行的线程都是守护线程时，程序运行后Java虚拟机将直接退出！
注意：setDaemon(true)方法必须在start()方法前执行，否则会抛出ILLegalThreadStateException异常。
在守护线程中产生的新线程也是守护线程。

Test1：

package com.gch.d9_thread_daemon;

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "@" +i);
        }
    }
}

package com.gch.d9_thread_daemon;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

package com.gch.d9_thread_daemon;

import com.gch.d2_api.MyThread;

public class ThreadDemo {
    public static void main(String[] args) {
        /*
             final void setDaemon(boolean on)   设置为守护线程
             细节:
                  当其他的非守护线程(女神线程)执行完毕后,守护线程(备胎线程)会陆续结束
             通俗易懂:
                     当女神线程结束了,那么备胎也没有存在的必要了
         */

        Thread t1 = new MyThread1();
        Thread t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("备胎");

        // 把第二个线程设置为守护线程(备胎线程)
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}

Test2：当唯一运行的线程都是守护线程时，程序运行后Java虚拟机将直接退出。

package com.gch.d9_thread_daemon;

/**
   当唯一运行的线程都是守护线程时,程序运行后Java虚拟机将直接退出。
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        // 1.创建线程对象
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(50000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.setDaemon(true); // 设置成守护线程,程序运行后线程不会休眠,Java虚拟机将直接退出

        // 2.启动线程 启动该线程后,有三个线程:t线程 / main线程 / GC线程
        t.start();
    }
}

守护线程的应用场景：当把聊天都关闭了，传输文件也就没有存在的必要了！

问题：主线程执行完，子线程也一定结束吗？

答：这取决于子线程是否是守护线程，如果子线程是守护线程，它将在主线程退出时终止，但是，如果子线程是非守护线程，那么即使在主线程退出后，子线程仍将继续执行。

三. 礼让线程 / 出让线程

public static void yield()：出让线程 / 礼让线程
表示出让当前CPU的执行权
只是尽可能地会让结果均匀一点儿，因为礼让后会重新去竞争CPU的执行权，有可能还是自己竞争到了！

package com.gch.d14_thread_yield;

public class MyThread extends Thread{
    /**
     * 设置线程名
     * @param name:线程名
     */
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() { // "飞机"  "坦克"
        for (int i = 1; i <= 100; i++) {
            System.out.println(getName() + "@" +i);
            // 表示出让当前CPU的执行权
            Thread.yield(); // 只是尽可能地会让结果均匀一点,因为礼让后会重新去竞争CPU的执行权,有可能还是自己竞争到了
        }
    }
}

package com.gch.d14_thread_yield;

/**
   public static void yield():出让线程 / 礼让线程
 */
public class ThreadDemo {
    public static void main(String[] args) {
        // 1.创建线程对象
        Thread t1 = new MyThread("飞机");
        Thread t2 = new MyThread("坦克");
        // 2.启动线程
        t1.start();
        t2.start();
    }
}

四. 插入线程 / 插队线程

package com.gch.d15_thread_join;

public class MyThread extends Thread {
    /**
     * 设置当前线程名
     * @param name:线程名
     */
    public MyThread(String name) {
        super(name);
    }

    public MyThread(){

    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

package com.gch.d15_thread_join;

/**
   public final void join():插入线程 / 插队线程
   join()方法是指,在一个a线程中,被另外一个b线程强行插队,那么就必须要等到b线程执行完成以后,才能回到a线程执行任务!
   join(毫秒时间)方法是指a线程可以让b线程插队一定的时间,超过这个时间,又公平去竞争CPU的执行权!
 */
public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1.创建线程对象
        Thread t = new MyThread("土豆");

        // 2.开启线程
        t.start();

        // 表示把t这个线程,插入到当前线程之前
        // t:土豆,子线程
        // 当前线程:main线程,主线程
        // 把子线程插入到主线程之前,等子线程里面所有的代码全部执行完了,才会轮到主线程去执行!
        t.join(); // 完全执行完毕
//        t.join(10); // 可以传入一个毫秒数,最多可以让你插队多少时间


        // 执行在main线程当中的
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程执行" + i);
        }
    }
}

如下图，把子线程插入到主线程之前，等子线程里面所有的代码全部执行完了，才会轮到主线程去执行！
总结：哪个线程调用了join()，哪个线程就先执行完毕，再执行
join()方法是指,在一个a线程中,被另外一个b线程强行插队,那么就必须要等到b线程执行完成以后,才能回到a线程执行任务!

join(毫秒时间)方法是指a线程可以让b线程插队一定的时间,超过这个时间,又公平去竞争CPU的执行权!

五. 中断线程

public final void stop() ，直接调用线程的stop方法强制终止这个线程，此方法已经由于可能不安全已经被弃用了，可能造成死锁，改用interrupt()

public void interrupt():设置中断标记位:中断这个线程方法,不是真的中断,只是去设置一个中断的标记为true,是否需要真的中断,需要捕获run方法抛出的异常,人工处理。或者在run方法中判断,早点结束run方法。

interrupt()只是改变中断状态而已，interrupt()不会中断一个正在运行的线程，这一方法实际上完成的是，给受阻塞的线程抛出一个中断信号。

一旦设置中断标记位，那么只要在这个线程中遇到了wait / join / sleep这三个方法中的任何一个，它就会让这个线程抛出一个中断异常，抛出中断异常后，我们可以自行用return方法提前结束线程，来达到中断的效果，这才是真正让线程中断的办法。

设置中断标记位这个方法的调用一定要在线程启动之后，才能生效！

// 获取线程的中断标记状态后,并清除中断状态

public static boolean interrupted() {return currentThread().isInterrupted(true);}

// 只获取线程的中断标记状态,不会去清除中断状态。用Thread.currentThread()去调用这个方法,直接用线程对象调用会报错,报该变量未初始化。

public boolean isInterrupted() {return isInterrupted(false);}

package com.gch.d16_thread_interrupt;

/**
 * 还是打饭的这个例子:饭盒在打饭的过程中掉了、打饭过程中睡着了
 * 我们其实没有办法让线程中断,只能通过设置一个标记位,来让线程可以通过一定的方式去中断线程,
   最好的方式就是让线程在执行的过程中抛出异常,来中断线程。
 * public void interrupt():设置中断标记位:中断这个线程方法,不是真的中断,
     只是去设置一个中断的标记为true,是否需要真的中断,
 *   需要捕获run方法抛出的异常,人工处理。 或者在run方法中判断,早点结束run方法。
 * 小结:
 *     1.注意:中断标记位的设置,一定是在线程启动之后
 *     2.中断方法不是真的中断线程,只是设置一个中断的标记位为true,遇到wait/join/sleep方法的时候会抛出中断异常。
 *     3.抛出中断异常后,自行用return方法提前结束线程,来达到中断的效果。
 *  // 获取线程的中断标记状态后,并清除中断状态
 *  public static boolean interrupted() {return currentThread().isInterrupted(true);}
 *  // 只获取线程的中断标记状态,不会去清除中断状态。
用Thread.currentThread()去调用这个方法,直接用线程对象调用会报错,报该变量未初始化。
 *  public boolean isInterrupted() {return isInterrupted(false);}
 */
public class ThreadDemo {
    public static void main(String[] args) {

        // 1.创建线程对象
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开始打饭");
                try {
//                    boolean interrupted1 = Thread.interrupted(); // 获取线程的中断标记状态后,清除中断状态
//                    System.out.println("线程是否中断:" + interrupted1);
//
//                    boolean interrupted2 = Thread.interrupted(); // 获取线程的中断标记状态后,清楚中断状态
//                    System.out.println("线程是否中断:" + interrupted2);

                    // 只是获取线程的中断标记状态
                    boolean isInterrupted = Thread.currentThread().isInterrupted();
                    System.out.println("线程是否中断:" + isInterrupted);

                    Thread.sleep(1000);
                } catch (InterruptedException e) {
//                    throw new RuntimeException(e); 把抛出的异常注释掉,加了return提前结束run方法,就好比是中断了,这才是真正让线程中断的办法。
                    return; // 提前结束这个任务,就好比是中断了,这才是真正让线程中断的办法。
                }
                System.out.println("开始打饭结束");
            }
        },"打饭线程");

        // 2.启动线程
        t1.start(); // 启动线程并不代表run方法就立马执行,它只是说线程处于一种就绪的状态,准备好去抢占CPU的执行权了!

        // 一旦设置中断标记位的话,那么只要在这个线程中遇到了这三个方法,那么它就会抛出异常
        // 只要调用wait,join,sleep这三个方法中的任何一个,它就会让这个线程抛出一个中断异常,
        // 抛出异常之后,我们人为的在异常中去处理即可让线程中断
        // 这就是我们真正让线程中断的最佳办法
        t1.interrupt(); // 设置中断标记位:[注意:设置中断标记位这个方法的调用一定要在线程启动之后,才能生效!]
    }
}

Surpass余sheng军

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
线程的优先级、守护线程、礼让线程、插入线程、中断线程

一. 线程的优先级一. 线程的优先级在计算机当中，线程的调度有两种方式：抢占式调度模型多个线程它是在抢夺CPU的执行权，CPU在什么时候执行哪条线程是不确定的，执行多长时间也是不确定的，所以抢占式调度它体现了一个随机性优先级高的线程获取的 CPU 时间片相对多一些。非抢占式调度 / 分时调度模型所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片轮流的执行执行的时间也是差不多的在Java当中，它采取了第一种抢占式调度模型的方式。抢占式调度，重点掌握两个字随机性。
复制链接

扫一扫