【多线程】Thread 类 详解

Thread 类 详解

  • 一. 创建线程
    • 1. 继承 Thread 类
    • 2. 实现 Runnable 接口
    • 3. 其他变形
    • 4. 多线程的优势-增加运行速度
  • 二. Thread 类
    • 1. 构造方法
    • 2. 常见属性
    • 3. 启动线程-start()
    • 4. 中断线程-interrupt()
    • 5. 线程等待-join()
    • 6. 线程休眠-sleep()
    • 7. 获取当前线程引用
  • 三. 线程的状态
    • 1. 观察线程的所有状态
    • 2. 线程状态和状态转移的意义
    • 3. 观察线程的状态和转移

一. 创建线程

1. 继承 Thread 类

  1. 继承 Thread 来创建一个线程类，并重写 run() 方法
class MyThread extends Thread {@Overridepublic void run() {System.out.println("这里是线程运行的代码");}
}
  1. 创建 MyThread 类的实例
MyThread t = new MyThread();
  1. 调用 start 方法启动线程
t.start(); // 线程开始运行

注意：只有调用 start 函数才真正的创建了一个线程。

2. 实现 Runnable 接口

更推荐使用这种方法， 因为 Runnable 只是描述了一个任务，至于任务通过进程、线程、线程池还是什么来执行的，Runnable 并不关心，使代码更好的解耦合。

  1. 实现 Runnable 接口
class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("这里是线程运行的代码");}
}
  1. 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.
Thread t = new Thread(new MyRunnable());
  1. 调用 start 方法
t.start(); // 线程开始运行

对比上面两种方法:

  • 继承 Thread 类, 直接使用 this 就表示当前线程对象的引用.
  • 实现 Runnable 接口, this 表示的是 MyRunnable 的引用. 需要使用 Thread.currentThread() 来获取当前线程引用。

3. 其他变形

  • 匿名内部类创建 Thread 子类对象
// 使用匿名类创建 Thread 子类对象
Thread t1 = new Thread() {@Overridepublic void run() {System.out.println("使用匿名类创建 Thread 子类对象");}
};
  • 匿名内部类创建 Runnable 子类对象
// 使用匿名类创建 Runnable 子类对象
Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("使用匿名类创建 Runnable 子类对象");}
});
  • lambda 表达式创建 Runnable 子类对象
// 使用 lambda 表达式创建 Runnable 子类对象
Thread t3 = new Thread(() -> System.out.println("使用匿名类创建 Thread 子类对象"));
Thread t4 = new Thread(() -> {System.out.println("使用匿名类创建 Thread 子类对象");
});

4. 多线程的优势-增加运行速度

可以观察多线程在一些场合下是可以提高程序的整体运行效率的。

  • 使用 System.nanoTime() 可以记录当前系统的 纳秒 级时间戳.
  • serial 串行的完成一系列运算. concurrency 使用两个线程并行的完成同样的运算.
class ThreadAdvantage {// 多线程并不一定就能提高速度，可以观察，count 不同，实际的运行效果也是不同的private static final long count = 10_0000_0000;public static void main(String[] args) throws InterruptedException {// 使用并发方式concurrency();// 使用串行方式serial();}private static void concurrency() throws InterruptedException {long begin = System.nanoTime();// 利用一个线程计算 a 的值Thread thread = new Thread(new Runnable() {@Overridepublic void run() {int a = 0;for (long i = 0; i < count; i++) {a--;}}});thread.start();// 主线程内计算 b 的值int b = 0;for (long i = 0; i < count; i++) {b--;}// 等待 thread 线程运行结束thread.join();// 统计耗时long end = System.nanoTime();double ms = (end - begin) * 1.0 / 1000 / 1000;System.out.printf("并发: %f 毫秒%n", ms);}private static void serial() {// 全部在主线程内计算 a、b 的值long begin = System.nanoTime();int a = 0;for (long i = 0; i < count; i++) {a--;}int b = 0;for (long i = 0; i < count; i++) {b--;}long end = System.nanoTime();double ms = (end - begin) * 1.0 / 1000 / 1000;System.out.printf("串行: %f 毫秒%n", ms);}
}

结果：
在这里插入图片描述

不是使用了多线程，速度一定提高

  • 多线程更适合于 CPU 密集型的程序，程序需要进行大量计算，使用多线程就可以充分利用 CPU 多核资源，如果计算量不大，主要时间用在创建线程上就得不偿失了。
  • 一个进程的多个线程共享同一份资源，资源是有限的，线程变多，竞争进一步加剧，如果时间很多浪费在竞争资源上，有可能拖慢整体的速度。
  • 多个线程之间到底是并发执行，还是并行执行是不确定的，只有真正的并行执行时，效率才有显著提升。

二. Thread 类

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。 Thread 类的对象就是用来描述一个线程执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理。

1. 构造方法

在这里插入图片描述

Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

2. 常见属性

在这里插入图片描述

  • ID： 线程的唯一标识，不同线程不会重复
  • 名称： 是各种调试工具用到
  • 状态： 表示线程当前所处的一个情况，下面将会进一步说明
  • 优先级： 优先级高的线程理论上来说更容易被调度到
  • 后台线程： 关于后台线程需要记住：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
  • 是否存活： 即简单的理解，为 run 方法是否运行结束了
  • 线程的中断问题： 下面将进一步说明
    public static void main(String[] args) {// 创建线程Thread thread = new Thread(() -> {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + ": 我还活着");Thread.sleep(1 * 1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName() + ": 我即将死去");});// （从 main 线程）获取 thread 线程的参数System.out.println("thread: ID: " + thread.getId());System.out.println("thread: 名称: " + thread.getName());System.out.println("thread: 状态: " + thread.getState());System.out.println("thread: 优先级: " + thread.getPriority());System.out.println("thread: 后台线程: " + thread.isDaemon());System.out.println("thread: 活着: " + thread.isAlive());System.out.println("thread: 被中断: " + thread.isInterrupted());// 启动 thread 线程thread.start();// 循环一直空转，至 thread 线程死亡while (thread.isAlive()) {}// 判断 thread 线程是否还活着System.out.println("thread: 状态: " + thread.getState());}

输出：
在这里插入图片描述

是否为后台线程：

  1. 若是后台线程，不影响程序的退出，前台线程才会影响程序的退出。
    （前台线程通常执行一些重要的任务，而后台线程用于执行一些辅助性的或者周期性的任务，以支持前台线程的工作。）

  2. 我们创建的线程默认是前台进程，所以即使 main 线程执行完毕了，进程也不能退出，需要等待我们创建的线程执行完毕。
    假如我们创建的是后台线程，那么 main 线程执行完毕后，进程直接退出，我们创建的线程即使没有执行完也被强制终止。

是否存活：

  • 调用 start() 之前，run() 方法执行完之后为 isAlive 为 false
  • 调用 start() 之后，run() 方法执行完之前为 isAlive 为 false

注意：Thread t 的生命周期和内核中线程的生命周期并不完全一致：
创建 t 对象后，调用 start() 之前，系统中没有对应的线程，
run() 执行完，系统中的线程销毁了，但 t 对象可能还在。

3. 启动线程-start()

之前我们已经看到了如何通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。

  • 覆写 run 方法是提供给线程要做的事情的指令清单
  • 而调用 start() 方法，就是喊一声：”行动起来！“，线程才真正独立去执行了。

调用 start 方法, 才真的在操作系统的底层创建出一个线程。
注意：一个线程只能 start 一次

start() 和 run() 的区别

  1. run 单纯的只是一个普通方法，描述了任务的内容，
    start 则是一个特殊的方法，内部会在系统中创建一个线程。
  2. run 只是一个普通的方法，在 main 线程里面调用 run, 并不会创建线程，只是在 main 线程中执行 run 中的代码，既然 run 和其他代码一样都是 在 main 线程中执行的，那么就得按照从前到后的顺序执行代码。

4. 中断线程-interrupt()

注意：中断一个线程，不是让线程立即就停止，只是通知该线程说你该停止了，具体是否真的停止，取决于线程里面代码的写法。（与操作系统里面的中断不一样）

线程一旦进到工作状态，他就会按照行动指南上的步骤（run 方法）去进行工作，不完成是不会结束的。但有时我们需要增加一些机制，例如张三（主线程）让 李四 （新创建的线程）进行转账业务，李四正在工作时，老板突然来电话了，说转账的对方是个骗子，需要赶紧停止转账，那张三该如何通知李四停止呢？这就涉及到我们的停止线程的方式了。

目前常见的有以下两种方式：

  1. 通过共享的标记来进行沟通
  2. 调用 interrupt() 方法来通知

示例-1: 使用自定义的变量来作为标志位.
因为多个线程共用一块空间，所以 多个线程修改的标志位是同一个。
注意需要给标志位上加 volatile 关键字，防止编译器优化为不访问内存，从而感知不到了标志位的变化。

class ThreadDemo {private static class MyRunnable implements Runnable {public volatile boolean isQuit = false;@Overridepublic void run() {while (!isQuit) {System.out.println(Thread.currentThread().getName()+ ": 别管我，我忙着转账呢!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName()+ ": 啊！险些误了大事");}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");System.out.println(Thread.currentThread().getName()+ ": 让李四开始转账。");thread.start();Thread.sleep(10 * 1000);System.out.println(Thread.currentThread().getName()+ ": 老板来电话了，得赶紧通知李四对方是个骗子！");target.isQuit = true;}
}

输出：
在这里插入图片描述

使用共享的标记来进行沟通的话，线程收到通知不及时，比如说线程在休眠，需要等到休眠结束后才能收到通知。

示例-2: 使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位.
（Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记. ）

在这里插入图片描述

  • 使用 thread 对象的 interrupt() 方法通知线程结束.
    （interrupt() 方法只是设置了一个标志位，具体要不要中断，还要被中断线程的配合，还是取决于被中断线程决定是否中断。）
class ThreadDemo {private static class MyRunnable implements Runnable {@Overridepublic void run() {// 两种方法均可以while (!Thread.interrupted()) {
//                while (!Thread.currentThread().isInterrupted()) {System.out.println(Thread.currentThread().getName()+ ": 别管我，我忙着转账呢!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();System.out.println(Thread.currentThread().getName()+ ": 有内鬼，终止交易！");// 注意此处的 breakbreak;}}System.out.println(Thread.currentThread().getName()+ ": 啊！险些误了大事");}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");System.out.println(Thread.currentThread().getName()+ ": 让李四开始转账。");thread.start();Thread.sleep(10 * 1000);System.out.println(Thread.currentThread().getName()+ ": 老板来电话了，得赶紧通知李四对方是个骗子！");thread.interrupt();}
}

thread 收到通知的方式有两种：

  1. 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志，也就是说 中断标志位为 false
  • 当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程.
  1. 否则，只是内部的一个中断标志被设置，thread 可以通过
  • Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志
  • Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志

使用 interrupt() 这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到，但是如果是自己使用的标志位的话，线程不能及时收到中断通知。

示例-3： 观察标志位是否清除

标志位是否清除, 就类似于一个开关.

  • Thread.isInterrupted() 相当于按下开关, 开关自动弹起来了. 这个称为 “清除标志位”
  • Thread.currentThread().isInterrupted() 相当于按下开关之后, 开关弹不起来, 这个称为 “不清除标志位”.

使用 Thread.isInterrupted() , 线程中断会清除标志位.
观察源码可以发现, Thread.isInterrupted() 内部实际上是调用了 Thread.currentThread().isInterrupted() 只不过参数传了一个 true, 代表清除标志位。

class ThreadDemo {private static class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.interrupted());}}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");thread.start();thread.interrupt();}
}

在这里插入图片描述
使用 Thread.currentThread().isInterrupted() , 线程中断标记位不会清除.

class ThreadDemo {private static class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().isInterrupted());}}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");thread.start();thread.interrupt();}
}

在这里插入图片描述

为什么一个清除，一个不清除？它们都用于什么场景 ？

Thread.interrupted() 清除标志位是为了下次继续检测标志位。如果一个线程被设置中断标志后，选择结束线程那么自然不存在下次的问题，而如果一个线程被设置中断标识后，进行了一些处理后选择继续进行任务，而且这个任务也是需要被中断的，那么当然需要清除标志位了。重新设置为 false, 这样就可以下次继续检测标志位。

5. 线程等待-join()

线程等待主要是为了控制线程结束的先后顺序。
有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。例如，张三只有等李四转账成功，才决定是否存钱，这时我们需要一个方法明确等待线程的结束。

在这里插入图片描述

class ThreadDemo {public static void main(String[] args) throws InterruptedException {Runnable target = () -> {for (int i = 0; i < 4; i++) {try {System.out.println(Thread.currentThread().getName()+ ": 我还在工作！");Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName() + ": 我结束了！");};Thread thread1 = new Thread(target, "李四");Thread thread2 = new Thread(target, "王五");System.out.println("先让李四开始工作");thread1.start();// 这行代码是在 main 线程中调用的，所以是 main 线程等待 thread1 线程结束，main 线程才能继续往下执行thread1.join();System.out.println("李四工作结束了，让王五开始工作");thread2.start();// 同理，这行代码是在 main 线程中调用的，所以是 main 线程等待 thread2 线程结束，main 线程才能继续往下执行下面的打印代码thread2.join();System.out.println("王五工作结束了");}
}

在这里插入图片描述

当把 join 方法注释掉：

class ThreadDemo {public static void main(String[] args) throws InterruptedException {Runnable target = () -> {for (int i = 0; i < 4; i++) {try {System.out.println(Thread.currentThread().getName()+ ": 我还在工作！");Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName() + ": 我结束了！");};Thread thread1 = new Thread(target, "李四");Thread thread2 = new Thread(target, "王五");System.out.println("先让李四开始工作");thread1.start();
//        thread1.join();System.out.println("李四工作结束了，让王五开始工作");thread2.start();
//        thread2.join();System.out.println("王五工作结束了");}
}

在这里插入图片描述

6. 线程休眠-sleep()

有一点要记得，因为线程的调度是不可控的，所以，这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。

在这里插入图片描述

class ThreadDemo {public static void main(String[] args) throws InterruptedException {System.out.println(System.currentTimeMillis());Thread.sleep(3 * 1000);System.out.println(System.currentTimeMillis());}
}

Thread.sleep(3 * 1000) 并不是 3s 后就上 CPU 执行 , 而是 3s 内上不了 CPU , 因为 sleep 就被放到阻塞队列里面了，休眠完成后被放入到就绪队列中，而就绪队列中不只 你这一个线程，而是多个线程都是就绪状态，等着上 CPU 执行。
在这里插入图片描述

线程休眠实质上就是将线程放到阻塞队列中。所以休眠是阻塞的一种，会释放 CPU（持有锁的话，并不会释放锁）。

7. 获取当前线程引用

在这里插入图片描述
注意，在哪个线程里面调用 Thread.currentThread() 得到的就是哪个线程
在 main 线程中调用：

class ThreadDemo {public static void main(String[] args) {// 注意，在哪个线程里面调用 Thread.currentThread() 得到的就是哪个线程Thread thread = Thread.currentThread();System.out.println(thread.getName());}
}

在这里插入图片描述

在创建出来的其他线程中调用：

class ThreadDemo {public static void main(String[] args) {// 注意，在哪个线程里面调用 Thread.currentThread() 得到的就是哪个线程Thread thread = new Thread(()->{// 这个是在 创建出来的线程里面调用的System.out.println(Thread.currentThread().getName());});thread.start();}
}

在这里插入图片描述

三. 线程的状态

1. 观察线程的所有状态

线程的状态是一个枚举类型 Thread.State

class ThreadState {public static void main(String[] args) {for (Thread.State state : Thread.State.values()) {System.out.println(state);}}
}

输出：
在这里插入图片描述

  • NEW: 安排了工作, 还未开始行动
  • RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
  • BLOCKED: 表示排队等着其他事情，比如等待锁 （阻塞状态）
  • WAITING: 这几个都表示排队等着其他事情（阻塞状态）
  • TIMED_WAITING: 这几个都表示排队等着其他事情（阻塞状态）
  • TERMINATED: 工作完成了.

为什么要这么细分 ？
因为开发过程中经常遇到程序卡死的情况，分析卡死的原因时，我们可以查看各个线程的状态，从而定位问题。

2. 线程状态和状态转移的意义

在这里插入图片描述

在这里插入图片描述

还是之前的例子：

  • 刚把李四、王五找来，还是给他们在安排任务，没让他们行动起来，就是 NEW 状态；

  • 当李四、王五开始去窗口排队，等待服务，就进入到 RUNNABLE 状态。该状态并不表示已经被银行工作人员开始接待，排在队伍中也是属于该状态，即可被服务的状态，是否开始服务，则看调度器的调度;

  • 当李四、王五因为一些事情需要去忙，例如需要填写信息、回家取证件、发呆一会等等时，进入 BLOCKED 、 WATING 、 TIMED_WAITING 状态；

  • 如果李四、王五已经忙完，为 TERMINATED 状态。

所以，之前我们学过的 isAlive() 方法，可以认为是处于不是 NEW 和 TERMINATED 的状态都是活着的。

3. 观察线程的状态和转移

  1. 观察 1: 关注 NEW 、 RUNNABLE 、 TERMINATED 状态的转换
  • 使用 isAlive 方法判定线程的存活状态.
class ThreadStateTransfer {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {for (int i = 0; i < 1000_0000; i++) {}}, "李四");System.out.println(t.getName() + ": " + t.getState()); // NEWt.start();while (t.isAlive()) {System.out.println(t.getName() + ": " + t.getState()); // RUNNABLE}System.out.println(t.getName() + ": " + t.getState()); // TERMINATED}
}
  1. 观察 2: 关注 WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换
class ThreadStateTransfer {public static void main(String[] args) {final Object object = new Object();Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (object) {while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}}}, "t1");t1.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (object) {System.out.println("hehe");}}}, "t2");t2.start();}
}

通过 jconsole 可以看出 t1 是 TIMED_WAITING，t2 是 BLOCKED
t1:

在这里插入图片描述
t2:

在这里插入图片描述

修改上面的代码, 把 t1 中的 sleep 换成 wait：

class ThreadStateTransfer {public static void main(String[] args) {final Object object = new Object();Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (object) {while (true) {try {// [修改这里就可以了!!!!!]// Thread.sleep(1000);object.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}, "t1");t1.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (object) {System.out.println("hehe");}}}, "t2");t2.start();}
}

使用 jconsole 可以看到 t1 的状态是 WAITING
在这里插入图片描述

结论:

  • BLOCKED 表示等待获取锁, WAITING 和 TIMED_WAITING 表示等待其他线程发来通知.
  • TIMED_WAITING 线程在等待唤醒，但设置了时限; WAITING 线程在无限等待唤醒
  1. 观察-3: yield() 大公无私，让出 CPU
class ThreadStateTransfer {public static void main(String[] args) {Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("张三");
//                     先注释掉, 再放开
//                     Thread.yield();}}}, "t1");t1.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("李四");}}}, "t2");t2.start();}
}

可以看到:

  1. 不使用 yield 的时候, 张三李四大概五五开
  2. 使用 yield 时, 张三的数量远远少于李四

结论:
yield 不改变线程的状态, 但是会重新去排队.

好啦！ 以上就是对 Thread 类的 详细讲解 ！希望能帮到你 ！
评论区欢迎指正 ！

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C# OpenCvSharp 通道分离

C# OpenCvSharp 通道分离

效果 项目 代码 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using OpenCvSharp; using OpenCvSharp.Extensions;namespac…
阅读更多...
Shell命令管理进程

Shell命令管理进程

Shell命令管理进程 列出进程 ps命令 top命令 管理后台进程 启动后台进程 查看后台进程 jobs和ps的区别 停止进程 Linux除了是一种多用户操作系统之外&#xff0c;还是一种多任务系统。多任务意味着可以同时运行多个程序。Linux 提供了相关的工具来列出运行中的进程,监视…
阅读更多...
TSINGSEE青犀视频AI分析/边缘计算/AI算法·安全帽检测功能——多场景高效运用

TSINGSEE青犀视频AI分析/边缘计算/AI算法·安全帽检测功能——多场景高效运用

安全帽检测算法主要是对人员安全和事故预防的需要。在许多工业领域和施工现场&#xff0c;佩戴安全帽是一种重要的安全措施&#xff0c;可以减少头部受伤的风险。然而&#xff0c;由于工地人员数量众多且繁忙&#xff0c;人工监控难以有效覆盖所有区域&#xff0c;因此旭帆科技…
阅读更多...
LeetCode 23 合并 K 个升序链表

LeetCode 23 合并 K 个升序链表

LeetCode 23 合并 K 个升序链表 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode.cn/problems/merge-k-sorted-lists/description/ 博主Github&#xff1a;https://github.com/GDUT-Rp/LeetCode 题目&#xff1a; 给你一个链表数组…
阅读更多...
算法通关村第12关【青铜】| 字符串转换问题

算法通关村第12关【青铜】| 字符串转换问题

1.转换成小写字母 思路&#xff1a;ASCll码中&#xff0c;a-z&#xff1a;97-122 A-Z&#xff1a;65-90 小写转大写-32&#xff0c;大写转小写32 class Solution {public String toLowerCase(String s) {int len s.length();StringBuilder str new StringBuilder();for(int…
阅读更多...
it监控系统可以电脑吗？有什么效果

it监控系统可以电脑吗？有什么效果

IT业务监控已经成为公司不可或缺的一部分&#xff0c;以确保业务的正常运行&#xff0c;提高企业的竞争能力。本文将详细介绍IT业务监控的必要性、实施方法以及如何选择合适的监控工具。 IT业务监控的必要性 确保业务稳定运行　　IT业务监控可以实时检测公司的工作流程&#x…
阅读更多...
蚂蚁发布金融大模型：两大应用产品支小宝2.0、支小助将在完成备案后

蚂蚁发布金融大模型：两大应用产品支小宝2.0、支小助将在完成备案后

9月8日&#xff0c;在上海举办的外滩大会上&#xff0c;蚂蚁集团正式发布金融大模型。据了解&#xff0c;蚂蚁金融大 模型基于蚂蚁自研基础大模型&#xff0c;针对金融产业深度定制&#xff0c;底层算力集群达到万卡规模。该大 模型聚焦真实的金融场景需求&#xff0c;在“认知…
阅读更多...
【已更新代码图表】2023数学建模国赛E题python代码--黄河水沙监测数据分析

【已更新代码图表】2023数学建模国赛E题python代码--黄河水沙监测数据分析

E 题 黄河水沙监测数据分析 黄河是中华民族的母亲河。研究黄河水沙通量的变化规律对沿黄流域的环境治理、气候变 化和人民生活的影响&#xff0c;以及对优化黄河流域水资源分配、协调人地关系、调水调沙、防洪减灾 等方面都具有重要的理论指导意义。 附件 1 给出了位于小浪底水…
阅读更多...
国产SSD的0e可靠性问题如何解决？

国产SSD的0e可靠性问题如何解决？

最近有粉丝在后台私信询问过程NAND的0e问题，觉得有必要跟大家聊聊小编的一些看法和SSD选购相关的注意事项。 说实话，小编看到0e这个词还一时间还有点恍惚了，0e是啥，我还搜索了一下，发现还挺多的。主要是长江存储和三星的词条。 点开才发现，原来0e是Media Error啊，恕我孤…
阅读更多...
3D点云测量：计算三个平面的交点

3D点云测量：计算三个平面的交点

文章目录 0. 测试效果1. 基本内容文章目录：3D视觉测量目录0. 测试效果 1. 基本内容 计算三个平面的交点需要找到满足所有三个平面方程的点。三个平面通常由它们的法向量和通过它们的点（或参数形式的方程）来定义。以下是计算三个平面的交点的一般步骤： 假设有三个平面，分别…
阅读更多...
Vue中的指令

Vue中的指令

指令 指令 (Directives) 是带有 v- 前缀的特殊 attribute。指令 attribute 的值预期是单个 JavaScript 表达式。指令的职责是&#xff0c;当表达式的值改变时&#xff0c;将其产生的连带影响&#xff0c;响应式地作用于 DOM。 常用指令预期简短介绍v-showany显示隐藏元素&…
阅读更多...
[html]当网站搭建、维护的时候，你会放个什么界面？

[html]当网站搭建、维护的时候，你会放个什么界面？

效果图&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>网站建设中</title><style>/* 基础样式 */body, html {margin: 0;padding: 0;height: 100%;font-family: Arial, sa…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023