第五章：LockSupport与线程中断

news2025/7/18 14:07:06

    • 阿里蚂蚁金服面试题
    • 什么是线程中断机制？
    • 中断相关的 API 方法
    • 面试题
      • 1、如果停止正在运行的一个线程？
      • 2 当前线程的中断标识为true，是不是线程就立刻停止？
        • 案例一
        • 案例二
      • 3、静态方法Thread.interrupted()，谈谈你的理解
    • 总结
  • LockSupport
    • 阻塞、唤醒现成的三种方式
      • park/unpark 实现阻塞/唤醒

阿里蚂蚁金服面试题

image-20221121221608262

  • 三个方法了解过吗？用在哪？
  • 如何停止一个运行中的线程？
  • 如何中断一个运行中的线程？？

什么是线程中断机制？

首先

一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。

所以，Thread.stop, Thread.suspend, Thread.resume 都已经被废弃了。

其次

在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。

因此，Java 提供了一种用于停止线程的协商机制——中断。

中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。若要中断一个线程，你需要手动调用该线程的 interrupt 方法，该方法也仅仅是将线程对象的中断标识设成true；接着你需要自己写代码不断地检测当前线程的标识位，如果为true，表示别的线程要求这条线程中断，此时究竟该做什么需要你自己写代码实现。

每个线程对象中都有一个标识，用于表示线程是否被中断；该标识位为true表示中断，为false表示未中断；

通过调用线程对象的interrupt方法将该线程的标识位设为true；可以在别的线程中调用，也可以在自己的线程中调用。

中断相关的 API 方法

方法描述
public void interrupt()实例方法，实例方法interrupt()仅仅是设置线程的中断状态为true，发起一个协商而不会立刻停止线程
public static boolean interrupted()静态方法，Thread.interrupted();判断线程是否被中断，并清除当前中断状态 这个方法做了两件事：1、返回当前线程的中断状态 2 、将当前线程的中断状态设为false（这个方法有点不好理解，因为连续调用两次的结果可能不一样。
public boolean isInterrupted()实例方法，判断当前线程是否被中断（通过检查中断标志位）

面试题

通过面试演示三个API的使用方法以及注意事项

1、如果停止正在运行的一个线程？

stopstop和suspend及resume一样都是过期作废的方法。因此不推荐使用

第一种方式，使用 volatile 中断线程：

利用 volatile 的可见性，用于判断是否中断的一个标志位

public class interruptTest01 {
    // 标志位
    static volatile boolean isStop = false;
    public static void main(String[] args) {

        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println(Thread.currentThread().getName()  +"\t" + "isStop 被修改为true，线程停止");
                    break;
                }
                System.out.println("hello, volatile....");
            }
        }, "t1").start();

        try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}
        
        new Thread(() -> {
            isStop =  true;
        }, "t2").start();
    }
}

第二种方式：通过 AtomicBoolean 中断

  static AtomicBoolean atomicBoolean =  new AtomicBoolean(false);
    public static void main(String[] args) {

        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()) {
                    System.out.println(Thread.currentThread().getName()  +"\t" + "atomicBoolean 被修改为true，线程停止");
                    break;
                }
                System.out.println("hello, atomicBoolean....");
            }
        }, "t1").start();

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

        new Thread(() -> {
            atomicBoolean.set(true);
        }, "t2").start();
    }

第三种方式：使用 Thread类 自带的 api 实现中断

   public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "\t" + "interrupted 被修改为true，线程停止");
                    break;
                }
                System.out.println("hello, interrupted....");
            }
        }, "t1");
        t1.start();

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

        new Thread(() -> {
            // 设置中断标志为 true
            t1.interrupt();
        }, "t2").start();

    }

2 当前线程的中断标识为true，是不是线程就立刻停止？

不是

案例一

  • 如果线程处于正常活动状态，那么会将该线程的中断标志设置为 true，仅此而已。被设置中断标志的线程将继续正常运行，不受影响。所以， interrupt() 并不能真正的中断线程，需要被调用的线程自己进行配合才行。

  • 中断不活动的线程不会产生任何影响，看下面案例

public class InterruptTest02 {
    public static void main(String[] args) {
       Thread t1 =  new Thread(() -> {
           
            for (int i = 0; i < 100; i++) {
                System.out.println("----- " + i);
            }
           // true,虽然中断标志位为 true，但是并没中断线程
           System.out.println("第二次中断标志: " + Thread.currentThread().isInterrupted());
        }, "t1");
       t1.start();
        System.out.println("默认中断标志状态: " + t1.isInterrupted() ); //false
        // 将标志位设置为true
        t1.interrupt();
        try {Thread.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("第一次中断标志: " + t1.isInterrupted()); //true
        try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}
        // 由于线程 t1已结束，对于结束的线程，中断不会产生任何影响
        System.out.println("第三次中断标志: " + t1.isInterrupted()); // false
    }
}

输出结果：

默认的中断标志为false

当设置中断标志为 true 时，线程并没有结束，因此中断需要线程配合

当线程结束，中断不会产生任何影响

默认中断标志状态: false
----- 0
----- 1
----- 2
----- 3
----- 4
----- 5
----- 6
----- 7
----- 8
----- 9
----- 10
----- 11
----- 12
----- 13
----- 14
----- 15
----- 16
----- 17
----- 18
----- 19
----- 20
----- 21
----- 22
----- 23
----- 24
----- 25
----- 26
----- 27
----- 28
----- 29
----- 30
----- 31
----- 32
----- 33
----- 34
----- 35
----- 36
----- 37
----- 38
----- 39
----- 40
----- 41
----- 42
----- 43
----- 44
----- 45
----- 46
----- 47
----- 48
----- 49
----- 50
----- 51
----- 52
----- 53
----- 54
----- 55
----- 56
----- 57
----- 58
----- 59
----- 60
----- 61
----- 62
第一次中断标志: true
----- 63
----- 64
----- 65
----- 66
----- 67
----- 68
----- 69
----- 70
----- 71
----- 72
----- 73
----- 74
----- 75
----- 76
----- 77
----- 78
----- 79
----- 80
----- 81
----- 82
----- 83
----- 84
----- 85
----- 86
----- 87
----- 88
----- 89
----- 90
----- 91
----- 92
----- 93
----- 94
----- 95
----- 96
----- 97
----- 98
----- 99
第二次中断标志: true
第三次中断标志: false

Process finished with exit code 0

案例二

如果线程处于被阻塞状态（例如处于sleep, wait, join 等状态），在别的线程中调用当前线程对象的interrupt方法，那么线程将立即退出被阻塞状态（中断状态将被清除），并抛出一 个InterruptedException异常。

public class InterruptTest03 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("中断标志位被修改: " + Thread.currentThread().isInterrupted() + "，线程停止");
                    break;
                }
                try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
                System.out.println("hello,interrupt");
            }
        }, "t1");
        t1.start();
        
        try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}
        t1.interrupt();
    }
}

输出结果：

6

从结果可以看出，当线程正处于 sleep 阻塞状态时，设置标志位为 true，会立刻打断阻塞状态，并抛出InterruptedException异常，最终要的是会导致线程处于死循环。因此想要避免死循环，需要在 catch 语句中再一次设置中断标志

image-20221122165836671

演示输出结果：

7

3、静态方法Thread.interrupted()，谈谈你的理解

Thread.interrupted() 会做俩件事请：

  • 返回当前线程的中断标志位的状态
  • 将标志位设置成 false
public class InterruptTest04 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+ "\t" + Thread.interrupted()); // false
        System.out.println(Thread.currentThread().getName()+ "\t" + Thread.interrupted());// false

        // 设置标志位为 true
        Thread.currentThread().interrupt();

        System.out.println(Thread.currentThread().getName()+ "\t" + Thread.interrupted());// true
        System.out.println(Thread.currentThread().getName()+ "\t" + Thread.interrupted());// false
    }
}

总结

  1. interrupt 方法仅仅是设置当前线程中断标志位为 true，并不会主动中断线程，线程的中断还需要线程自己配合（程序员手动判断标志位进行中断）
  2. 处于正在活动的线程，interrupt 方法会将中断标志位设置成 true
  3. 对于不活动的线程（结束的线程），interrupt 方法并不会影响当前线程的中断标志
  4. 对于处在阻塞状态下的线程来说，执行 interrupt 方法会导致抛出 InterruptedException 异常，并且会导致死循环。因此线程中如果有阻塞的情况，一定要在catch语句块中再次调用 interrupt 方法

isInterrupted 和 interrupted 的区别？

  • interrupted 为静态方法
  • isInterrupted 仅仅返回当前线程的中断标志位状态，interrupted 不仅返回了中断标志位状态，还会将中断标志位设置成false

源码中的区别：

image-20221122171555905

LockSupport

官方解释：用于创建锁和其他同步类的基本线程阻塞原语。

image-20221122203605468

核心 API ：

static voidpark() 禁止当前线程进行线程调度，除非许可证可用。
static void``unpark(Thread thread)为给定的线程提供许可证（如果尚未提供）。

阻塞、唤醒现成的三种方式

  1. 使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
  2. 使用 JUC 包中Condition的await()方法让线程等待，使用signal()方法唤醒线程
  3. LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

使用 wait、notify 演示：

使用 wait、notify 时的注意点

  • wait、notify 必须在同步代码块中或者 同步方法中使用，否则会报 IllegalMonitorStateException 异常
  • 在顺序上，一定是先 wait() ，在 notify()
  • 线程的锁对象、以及调用 wait、notify 的对象必须为同一个对象
public class WaitNotifyTest {
    public static void main(String[] args) {
        Object obj = new Object();
         new Thread(() -> {
            synchronized (obj) {
                System.out.println(Thread.currentThread().getName() + "  come in...");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "  end");
        }, "t1").start();

        try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}
        new Thread(() -> {
            synchronized (obj) {
                System.out.println(Thread.currentThread().getName() + " 唤醒t1...");
                // 唤醒线程
                obj.notify();
            }
        }, "t2").start();
    }
}

使用 await、signal 演示

使用时的注意事项和wait notify 一样。

public class LockSupportTest01 {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "  come in...");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName() + "  end");
        }, "t1").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " 唤醒t1...");
                // 唤醒线程
                condition.signal();
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }
}

以上俩种方式使用的局限性：

  • 局限一：线程先要获得并持有锁，必须在锁块（synchronized或lock）中
  • 局限二：必须要先等待后唤醒，线程才能够被唤醒

因此衍生出了 park/unpark

park/unpark 实现阻塞/唤醒

通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作。

park 相当于 wait、await 方法 用来阻塞线程， unpark 相当于 notify、signal 方法 用来唤醒线程。

而 park/ unpark 与另外俩种方式的区别：

  • park/ unpark 不会抛出异常，另外俩种方式会抛出 InterruptedException

  • park/ unpark 采用 Permit （许可证） 的方式来阻塞、唤醒线程，每个使用 LockSupport 的线程都有一个许可证

  • 调用一次 park 方法会消耗掉一张 许可证，因此当前线程会进入阻塞状态

  • unpark 会为指定的线程发放一张许可证，如果线程处于阻塞状态，会将线程唤醒。无论调用多少次，只会发放一张许可证

LockSupport 和 Semaphore 不同的是，LockSupport 的许可证只有一张，无法累加。消耗完就会被阻塞。

代码演示一：

我们可以看到，park、unpark 并没在同步块中使用，LockSupport 并没有范围的局限性。

public class LockSupportTest01 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            
            System.out.println(Thread.currentThread().getName() + " come in...");
            // 消耗许可证
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "  end...");

        }, "t1");
        t1.start();

		try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 为 t1 发放许可证...");
            // 发放许可证
            LockSupport.unpark(t1);

        }, "t2").start();
    }
}

代码演示二：、

park、unpark 并没有执行顺序的问题，也就是先唤醒在阻塞也不会出现 IllegalMonitorStateException 异常。

public class LockSupportTest01 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}
            System.out.println(Thread.currentThread().getName() + " come in...");
            // 消耗许可证
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "  end...");

        }, "t1");
        t1.start();


        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 为 t1 发放许可证...");
            // 发放许可证
            LockSupport.unpark(t1);

        }, "t2").start();
    }
}

输出结果：

8

代码演示三：

演示许可证的唯一性

消耗三张许可证，而 无论调用多少次 unpark 都只会发放一张许可证。 因此许可证不够，线程进入阻塞状态

public class LockSupportTest01 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}
            System.out.println(Thread.currentThread().getName() + " come in...");
            // 消耗许可证
            LockSupport.park();
            LockSupport.park();
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "  end...");

        }, "t1");
        t1.start();


        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 为 t1 发放许可证...");
            // 发放许可证
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);

        }, "t2").start();
    }
}

结果：

image-20221122220508896

各位彭于晏，如有收获点个赞不过分吧…✌✌✌

Alt

扫码关注公众号 【我不是秃神】 回复 JUC 可下载 MarkDown 笔记

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/36114.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

国外服务器采取数据备份和灾难恢复的重要性

国外服务器采取数据备份和灾难恢复的重要性

在国外服务器的使用中&#xff0c;数据的安全性和完整性是任何组织都不能忽视的问题。丢失数据可能会对业务造成毁灭性的影响&#xff0c;因此必须有一个完善的数据备份和灾难恢复计划。 什么是备份? 备份将数据复制到辅助形式&#xff0c;如存档文件&#xff0c;在灾难发生时…
阅读更多...
网络安全：SQL盲注概述

网络安全：SQL盲注概述

目录 盲SQL注入 什么是盲SQL注入&#xff1f; 通过触发条件响应来利用盲SQL注入 通过触发 SQL 错误来诱导条件响应 通过触发时间延迟来利用盲 SQL 注入 使用带外 &#xff08;OAST&#xff09; 技术利用盲 SQL 注入 如何防止SQL注入 二阶 SQL 注入 特定于数据库的因素…
阅读更多...
4.每天不同时间段通过微信发消息提醒女友

4.每天不同时间段通过微信发消息提醒女友

目录 sentence_good_dinner.txt README.MD say_to_lady.py sentence_good_dream.txt sentence_good_lunch.txt sentence_good_dinner.txt 公主&#xff01;记得吃晚饭。 下班了&#xff0c;记得吃晚饭哦。 记得多吃点饭 你吃晚饭吧&#xff1f; 宝宝吃晚饭了吗&#xff0…
阅读更多...
《从零开始：机器学习的数学原理和算法实践》chap1

《从零开始：机器学习的数学原理和算法实践》chap1

《从零开始&#xff1a;机器学习的数学原理和算法实践》chap1 学习笔记 文章目录《从零开始&#xff1a;机器学习的数学原理和算法实践》chap1 学习笔记chap1 补基础&#xff1a;不怕学不懂微积分1.1 深入理解导数的本质直观理解复合函数求导1.2 理解多元函数偏导1.3 理解微积分…
阅读更多...
超纯水系统中硼离子去除技术原理

超纯水系统中硼离子去除技术原理

硼在元素周期表里面是五号元素&#xff0c;是IIIA族中唯一 一个非金属元素。它是制造P型半导体的主要 掺杂剂&#xff0c;基材中硼的含量直接影响半导体的极限电压&#xff0c;因此要严格控制基材中硼的含量。在半导体 制造的过程中&#xff0c;水、气、化直接跟产品接触&…
阅读更多...
b站黑马JavaScript的Ajax案例代码——图书管理案例

b站黑马JavaScript的Ajax案例代码——图书管理案例

目录 目标效果&#xff1a; 重点原理&#xff1a; 1.js数组操作中push方法 2.jquery中append方法 3.js数组操作中join方法 4.jQuery中attr方法 5.jQuery中trim方法 代码部分&#xff1a; 1. 图书管理案例.html(js部分全是重点&#xff0c;html部分用于看结构) 2.jquery.js…
阅读更多...
软考-系统架构师-计算机与网络基础知识-计算机网络基础知识

软考-系统架构师-计算机与网络基础知识-计算机网络基础知识

文章目录1.网络概述1.1开放系统互连参考模型1.2OSI协议集2.计算机网络2.1广域网局域网和城域网2.2网络互联2.3Internet3.网络管理与网络安全3.1网络管理3.2计算机网络安全3.3VPN4.网络工程5.存储及负载均衡技术5.1RAID技术5.2网络存储技术注1.网络概述 计算机网络通信按距离&a…
阅读更多...
论文阅读笔记 | 三维目标检测——PointPillars算法

论文阅读笔记 | 三维目标检测——PointPillars算法

如有错误&#xff0c;恳请指出。 文章目录1. 背景2. 网络结构3. 实验结果paper&#xff1a;《PointPillars: Fast Encoders for Object Detection from Point Clouds》 1. 背景 PointPillars的出发点同样与SECOND一样&#xff0c;希望改进VoxelNet所使用3d卷积计算量太大推理…
阅读更多...
Docker 安装 mysql5.7

Docker 安装 mysql5.7

docker拉取镜像命令 docker pull mysql:5.7 docker安装MySQL命令 docker run -p 3306:3306 --name mysql -v /mydata/mysql/log:/var/log/mysql -v /mydata/mysql/data:/var/lib/mysql -v /mydata/mysql/conf:/etc/mysql -e MYSQL_ROOT_PASSWORDroot -d mysql:5.7 修改MySQL的…
阅读更多...
SpringBoot2.7.4整合Redis

SpringBoot2.7.4整合Redis

目录 一、添加maven依赖 二、添加配置项 三、新增配置类 四、编辑实体类 五、编写接口 六、编写业务层 1.编写service层 2.编写service实现层 七、测试接口 一、添加maven依赖 <dependency><groupId>org.springframework.boot</groupId><artif…
阅读更多...
@PostConstruct详解

@PostConstruct详解

1、 Servlet中增加了两个影响Servlet生命周期的注解&#xff0c;PostConstruct和PreDestroy&#xff0c;这两个注解被用来修饰一个非静态的void&#xff08;&#xff09;方法。写法有如下两种方式&#xff1a; PostConstruct public void someMethod(){} 或者 public PostConst…
阅读更多...
第六章：Java内存模型之JMM

第六章：Java内存模型之JMM

有关JMM的面试题&#xff1f;计算机硬件存储体系Java内存模型Java Memory Model概念原则能干什么JMM三大特性原子性可见性有序性JMM规范下&#xff0c;多线程对变量的读写过程JMM规范下&#xff0c;多线程先行发生原则之happens-beforehappens-before 先行发生原则的概念Happen…
阅读更多...
CentOS中yum install命令如何找到安装包的下载地址

CentOS中yum install命令如何找到安装包的下载地址

我们通常用的yum install命令是怎么找到我们想要的下载地址的&#xff0c;这里简单做一下分析 首先&#xff0c;搜索所有/etc/yum.repos.d下所有repo 在每个repo中都有一个baseurl&#xff0c;这里以docker-ce.repo下载containerd.io 的rpm包为例 docker-ce的部分repo为 [do…
阅读更多...
怎么去除视频上的文字？一篇教你：视频上的文字水印怎么去除

怎么去除视频上的文字？一篇教你：视频上的文字水印怎么去除

原创视频更能够吸引人&#xff0c;但是毕竟热点有限&#xff0c;想要随时保持活跃度和吸引力就必须借助更多的视频素材来留住粉丝。但是很多视频素材是有水印、文字、LOGO或者一些图像的&#xff0c;那怎么去除视频上的文字呢&#xff1f;小编一篇简单文章教你怎么去除视频上的…
阅读更多...
GEO振弦式钢筋计的组装

GEO振弦式钢筋计的组装

&#xff08;1&#xff09;按钢筋直径选配相应的钢筋计&#xff0c;如果规格不符合&#xff0c;应选择尽量接近于结构钢筋直径 的钢筋计&#xff0c;例如&#xff1a;钢筋直径为 35mm&#xff0c;可使用 NZR-36 或 NZR-32 的钢筋计&#xff0c;此时仪器的最小 读数应进行修…
阅读更多...
Quarkus 集成 mailer 使用 easyexcel 发送表格邮件

Quarkus 集成 mailer 使用 easyexcel 发送表格邮件

前言 在quarkus 项目开发中,需要实现一个把用户数据写入到excel 表格中,然后发送邮件给到对应的用户邮箱上,在查找了Quarkus 官方文档后发现,Quarkus 对于发送邮箱的服务是天然支持的. 官方文档: https://cn.quarkus.io/guides/mailer 环境配置 首先发送邮箱服务,那么就需要有…
阅读更多...
CAS:89485-61-0，mPEG-N3，mPEG-Azide，甲氧基-peg-叠氮试剂供应

CAS:89485-61-0，mPEG-N3，mPEG-Azide，甲氧基-peg-叠氮试剂供应

mPEG-N3&#xff08;mPEG-Azide&#xff09;中文名为甲氧基-聚乙二醇-叠氮&#xff0c;它所属分类为Azide PEG Methoxy PEG。CAS编号为89485-61-0。 peg试剂的分子量均可定制&#xff0c;有&#xff1a;甲氧基-聚乙二醇-叠氮 5k、甲氧基-PEG-叠氮 10k、mPEG-Azide 2k、甲氧基-…
阅读更多...
error20221125--ssm项目用maven打包报错“找不到程序包 java.lang”或者“程序包javax.crypto不存在”，以及解决方案

error20221125--ssm项目用maven打包报错“找不到程序包 java.lang”或者“程序包javax.crypto不存在”，以及解决方案

从svn拉的ssm项目&#xff0c;写完代码准备发测试&#xff1b;结果用maven打war包的时候报错了 这个时候在控制台找到报错信息如下图 说“在类路径或引导类路径中找不到程序包 java.lang”&#xff1b; 我寻思着&#xff0c;java.lang不是jdk中基础的包吗&#xff1f;不应该有…
阅读更多...
c盘哪些文件可以删除？正确答案在这里！

c盘哪些文件可以删除？正确答案在这里！

当我们使用电脑时&#xff0c;经常下意识把各种文件数据保存在c盘&#xff0c;导致c盘的空间越来越小。想要清理电脑缓存&#xff0c;c盘哪些文件可以删除&#xff1f;注意&#xff0c;清理文件之前&#xff0c;记得要备份好重要的数据&#xff01;下面一起来看看哪些c盘文件可…
阅读更多...
PyQt5 QDockWidget

PyQt5 QDockWidget

PyQt5 QDockWidget方法描述setWidget()在Dock窗口区域设置QWidgetsetFloating()设置Dock窗口是否可以浮动&#xff0c;如果设置为True&#xff0c;则表示可以浮动setAllowedAreas()设置窗口可以停靠的区域 ●LeftDockWidgetArea:左边停靠区域●RightDockWidgetArea:右边停靠区域…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023