Java 线程运行方法和原理

news2024/9/24 19:21:35

线程运行

原理

栈与栈帧：

Java 虚拟机栈会为每个启动的线程分配一块栈内存，其中存储着栈帧（Frame）

  • 每个栈由多个栈帧组成，栈帧对应调用方法（函数）所占用的内存
  • 每个栈只有一个活动栈，对应当前正在执行的方法

单线程示例：

main, method1, method2 各自对应这一个栈帧，存储在一个栈中：

在这里插入图片描述

public class d1_Frame {
    public static void main(String[] args) {
        method1(10); // 调用method1
    }

    public static void method1(int x){
        int y = x + 1;
        Object obj = method2(); // 调用 method2
    }
    public static Object method2(){
        Object obj = new Object();
        return obj;
    }
}

在这里插入图片描述

多线程示例：

包含两个线程 main 和 t1 ，分别创建两个独立的栈，每个栈里包含各自的栈帧

main线程的栈：

xxx

t1 线程的栈：

xxx

public class d1_Frame {
    public static void main(String[] args) {

        Thread t1 = new Thread() {
            @Override
            public void run() {
                method1(20); // t1 线程调用 method1
            }
        };
        t1.setName("t1");
        t1.start();
        method1(10); // main 调用method1
    }

    public static void method1(int x){
        int y = x + 1;
        Object obj = method2(); // 调用 method2
    }
    public static Object method2(){
        Object obj = new Object();
        return obj;
    }
}

线程上下文切换（Thread Context Switch）

线程上下文切换是指：CPU不再执行当前线程，转而执行其他线程的代码的过程

发生 Context Switch 的原因：

  • 线程的 cpu 时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念
就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

  • 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
  • Context Switch 频繁发生会影响性能

线程运行的常见方法

xx

run与start

run调用：直接调用 run 方法，则是 main 主线程执行的，并没有创建一个新线程执行

start调用：创建一个新的线程 t1 ，t1 线程与 main 线程是同时进行的。调用后，线程的状态也会发生改变

@Slf4j(topic = "c.d2_run_start")
public class d2_run_start {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running");
            }
        };

        t1.run();
        // 14:25:50 [main] c.d2_run_start - running
        System.out.println(t1.getState()); //NEW

        t1.start();
        // 14:28:11 [t1] c.d2_run_start - running
        System.out.println(t1.getState()); // RUNNABLE
    }
}

sleep

  1. sleep 的对线程状态的影响：调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
@Slf4j(topic = "c.d3_sleep_yield")
public class d3_sleep_yield {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                log.debug("running");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }
            }
        };
        log.debug("t1 state: {}", t1.getState()); // NEW
        t1.start();
        log.debug("t1 state: {}", t1.getState()); // RUNNABLE

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state: {}", t1.getState()); // TIMED_WAITING
    }
}
  1. 其它线程可以使用 interrupt 方法中断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException 异常
@Slf4j(topic = "c.d3_sleep_yield")
public class d3_sleep_yield {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                log.debug("enter sleep");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.debug("wake up ...");
                   e.printStackTrace();
                }
            }
        };
        t1.start();

        try {
            Thread.sleep(1000); // 当前 main 线程睡眠1s
            log.debug("interrupt...");
            t1.interrupt(); // 打断 t1 的 sleep

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /**
         * 输出：
         * 14:45:29 [t1] c.d3_sleep_yield - enter sleep
         * 14:45:30 [main] c.d3_sleep_yield - interrupt...
         * 14:45:30 [t1] c.d3_sleep_yield - wake up ...
         * java.lang.InterruptedException: sleep interrupted
         */
    }
}

  1. 睡眠结束后的线程未必会立刻得到执行。睡眠结束后的线程仅仅是被唤醒了，还需要等待CPU分配时间片才能执行

  2. TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

iimport java.util.concurrent.TimeUnit;
// 该方法实际上是封装的 Thread.sleep 方法
TimeUnit.SECONDS.sleep(1); // 睡眠 1 s

yield

yield（让出）：让出当前线程 CPU 的使用权给其他线程

  1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程

  2. 具体的实现依赖于操作系统的任务调度器

线程优先级 set/getPriority

  • 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，任务调度器可以忽略它
  • 如果 CPU 比较忙，那么优先级高的线程会获得更多的时间片，但 CPU闲时，优先级几乎没作用
public class d4_thread_priority {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            int count = 0;
            while(true){
                System.out.println("---> 1 " + count++);
            }
        }, "t1");


        Thread t2 = new Thread(()->{
            int count = 0;
            while(true){
//                Thread.yield();
                System.out.println("         ---> 2 " + count++);
            }
        }, "t2");

        // 设置线程优先级（默认优先级为5）
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}
  • 设置 yield 会将当前线程占用的CPU时间片让给其他线程，所以 t1的 count 会比 t2 的大
  • 设置优先级，优先级越大的线程可以获得更多的时间片，所以 t2的 count 会比 t1 的大

防止 CPU 占用100%

xxx

join

等待当前线程运行完毕

单线程等待：主线程 main 在同步等待 t1 线程

@Slf4j(topic = "c.d5_join")
public class d5_join {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束");
            r = 10;
        });
        t1.start();
        t1.join(); // 等待 t1 完成，再获取 r的结果
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

xx

多线程等待：

@Slf4j(topic = "c.d5_join")
public class d5_join {
    static int r1 = 0;
    static int r2 = 0;
    public static void main(String[] args) throws InterruptedException {
        test2();
    }
    private static void test2() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            r2 = 20;
        });
        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
        // 15:23:57 [main] c.d5_join - r1: 10 r2: 20 cost: 2014
    }

先调用 t1 的 join 再调用 t2 的join，等待时间为 2s

  • 第一个 join：等待 t1 时, t2 并没有停止, 而在运行
  • 第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

颠倒两个 join 最终都是输出 2s

  • 因为 t2等待运行完成的时候，t1 也在运行
  • t2 完成后已经等待了 2s，此时t1已经运行完毕，不需要再等待了

xx

有时效的 join：

t1.join(1500); // 等待1.5后继续当前线程
// 如果 t1 仅需要 1s 完成，则join也会提前结束

interrupt

  1. 用于打断 sleep, wait, join的线程

打断后的打断标记为 false （认为对 sleep,wait,join的线程进行打断不算打断）

@Slf4j(topic = "c.d6_interrupt")
public class d6_interrupt {

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(()->{
            log.debug("sleep...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "t1");
        t1.start();
        Thread.sleep(500);
        log.debug("interrupt...");
        t1.interrupt();
        log.debug(" 打断状态: {}", t1.isInterrupted());
        /** 输出：
         * 15:36:35 [t1] c.d6_interrupt - sleep...
         * 15:36:36 [main] c.d6_interrupt - interrupt...
         * 15:36:36 [main] c.d6_interrupt -  打断状态: false
         */
    }
}
  1. 打断正常运行的线程

打断后的打断标记为 true。但是被打断的线程并不会停止运行

这样可以通过一个标记让该线程获取自己被其他线程打断了，以便进行后续处理并决定是否停止当前线程

@Slf4j(topic = "c.d6_interrupt")
public class d6_interrupt {

    public static void main(String[] args) throws InterruptedException {
        test2();
    }

    private static void test2() throws InterruptedException {
        Thread t2 = new Thread(()->{
            while(true) {
                // 获取当前线程的打断标记
                Thread current = Thread.currentThread();
                boolean interrupted = current.isInterrupted();
                // 自己决定是否退出当前线程
                if(interrupted) {
                    log.debug(" 打断状态: {}", interrupted);
                    // 15:39:55 [t2] c.d6_interrupt -  打断状态: true
                    break;
                }
            }
        }, "t2");
        t2.start();
        Thread.sleep(500);
        t2.interrupt();
    }
}

模式之两阶段终止

Two Phase Termination
在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

  1. 错误方法
  • 使用线程对象的 stop() 方法停止线程
    • stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
  • 使用 System.exit(int) 方法停止线程
    • 目的仅是停止一个线程，但这种做法会让整个程序都停止
  1. 两阶段终止模式

sss

利用 isInterrupted

注意事项：

sleep过程中被打断会重置打断标记为false，所以需要重新设置打断标记为 true，以便在上面的if里判断标记，进行后续处理

如果不重新设置打断标记为 true，则不会进行料理后事的处理

class Test{
    public static void main(String[] args) throws InterruptedException {
        d7_two_phase_termination tpt = new d7_two_phase_termination();
        tpt.start();

        Thread.sleep(3500);
        tpt.stop();
        /** 输出：
         * 16:07:57 [Thread-0] c.d7_two_phase_termination - 执行监控记录
         * 16:07:58 [Thread-0] c.d7_two_phase_termination - 执行监控记录
         * 16:07:59 [Thread-0] c.d7_two_phase_termination - 执行监控记录
         * java.lang.InterruptedException: sleep interrupted
         * 	at java.base/java.lang.Thread.sleep0(Native Method)
         * 	at java.base/java.lang.Thread.sleep(Thread.java:509)
         * 	at com.rainsun.d2_run_thread.d7_two_phase_termination.lambda$start$0(d7_two_phase_termination.java:30)
         * 	at java.base/java.lang.Thread.run(Thread.java:1583)
         * 16:08:00 [Thread-0] c.d7_two_phase_termination - 释放资源，锁，料理后事...
         */
    }
}

@Slf4j(topic = "c.d7_two_phase_termination")
public class d7_two_phase_termination {
    private Thread monitor;

    // 启动监控程序
    public void start(){
        monitor = new Thread(()->{
            while (true){
                Thread currentThread = Thread.currentThread();
                if(currentThread.isInterrupted()){
                    log.debug("释放资源，锁，料理后事...");
                    break;
                }

                try {
                    Thread.sleep(1000); // 情况一：sleep过程被打断
                    log.debug("执行监控记录"); // 情况二：执行其他过程被打断
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // sleep过程中被打断会重置打断标记为false
                    // 这里需要重新设置打断标记为 true，以便在上面的if里判断标记，进行后续处理
                    currentThread.interrupt();
                }
            }
        });
        monitor.start();
    }

    public void stop(){
        monitor.interrupt();
    }
}

主线程与守护线程

  • 默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。

    • 例如：两个线程t1，main ，main线程结束了， t1 线程没结束则Java进程会继续运行

  • 有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

    • 设置一个线程为守护线程：t1.setDaemon(true)

t1 2s才运行完，但是 t1 被设置为守护线程，当其他线程 1s后运行完后，t1 线程也被迫停止了

@Slf4j(topic = "c.d8_daemon")
public class d8_daemon {
    public static void main(String[] args) throws InterruptedException {
        log.debug("开始运行...");
        Thread t1 = new Thread(() -> {
            log.debug("开始运行...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            log.debug("运行结束...");
        }, "daemon");
        // 设置该线程为守护线程
        t1.setDaemon(true);
        t1.start();
        Thread.sleep(1000);
        log.debug("运行结束...");
        /**
         * 16:22:39 [main] c.d8_daemon - 开始运行...
         * 16:22:39 [daemon] c.d8_daemon - 开始运行...
         * 16:22:40 [main] c.d8_daemon - 运行结束...
         */
    }
}

注意

  • 垃圾回收器线程就是一种守护线程
  • Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

操作系统层面的五种状态

在这里插入图片描述

  • 【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
  • 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
  • 【运行状态】指获取了 CPU 时间片运行中的状态当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
  • 【阻塞状态】
    • 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
    • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
    • 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
  • 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

Java API 层面的六种状态

aa

  • NEW 线程刚被创建，但是还没有调用 start() 方法
  • RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
  • BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述
  • TERMINATED 当线程代码运行结束

六种状态的演示：

@Slf4j(topic = "c.d9_thread_state")
public class d9_thread_state {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            log.debug("running..."); // NEW
        }, "t1");


        Thread t2 = new Thread(()->{
            while (true){ // RUNNABLE

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

        Thread t3 = new Thread(()->{
            log.debug("running..."); // TERMINATED
        }, "t3");
        t3.start();

        Thread t4 = new Thread(()->{
            synchronized (d9_thread_state.class){
                try {
                    Thread.sleep(1000000); // timed_waiting
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }, "t4");
        t4.start();

        Thread t5 = new Thread(()->{
            try {
                t2.join(); // t5等待t2完成，t2为死循环，所以是 waiting状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t5");
        t5.start();

        Thread t6 = new Thread(()->{
            // 这个锁已经被t4占据了，所以t6拿不到这个锁。陷入 blocked状态
            synchronized (d9_thread_state.class){
                try {
                    Thread.sleep(1000000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }, "t6");
        t6.start();

        Thread.sleep(500);

        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());
        /** 输出：
         * 16:47:45 [t3] c.d9_thread_state - running...
         * 16:47:46 [main] c.d9_thread_state - t1 state NEW
         * 16:47:46 [main] c.d9_thread_state - t2 state RUNNABLE
         * 16:47:46 [main] c.d9_thread_state - t3 state TERMINATED
         * 16:47:46 [main] c.d9_thread_state - t4 state TIMED_WAITING
         * 16:47:46 [main] c.d9_thread_state - t5 state WAITING
         * 16:47:46 [main] c.d9_thread_state - t6 state BLOCKED
         */

    }
}

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

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

相关文章

羊大师解读，血压波动

羊大师解读，血压波动

羊大师解读，血压波动 血压是身体健康的一个重要指标，但有时候我们会发现血压存在着波动的情况。血压波动的原因有很多，包括生活方式、遗传因素、药物影响等等。本文小编羊大师将为大家详细介绍血压波动的原因，以及预防和管理血压…
阅读更多...
无脑利用API实现文心一言AI对话功能？(附代码)

无脑利用API实现文心一言AI对话功能？(附代码)

前言：在当今数字化的时代，人工智能（AI）技术正在不断演进，为开发者提供了丰富的工具和资源。其中，API（应用程序接口）成为构建强大AI应用的关键组成部分之一。本文将介绍如何利用API来…
阅读更多...
git的分支的使用，创建分支，合并分支，删除分支，合并冲突，分支管理策略，bug分支，强制删除分支

git的分支的使用，创建分支，合并分支，删除分支，合并冲突，分支管理策略，bug分支，强制删除分支

GIT | 分支 文章目录 GIT | 分支创建分支合并分支删除分支合并冲突分支管理策略bug分支强制删除分支 创建分支 查看当前本地仓库中有哪些分支 git branchHEAD所指向的分支就是当前正在工作的分支 cat .git/HEAD创建一个分支 git branch dev创建好了，但是目前还是…
阅读更多...
计算机组成原理—中央处理器CPU

计算机组成原理—中央处理器CPU

文章目录 CPU的功能与架构CPU的组成运算器控制器 指令执行过程指令流程指令执行方案 数据通路单总线结构专用通路结构 硬布线控制器设计硬布线执行流程硬布线CU内部怎么设计微操作的组合电路 总结 微程序控制器设计微程序的基本理念微程序的基本结构 微指令设计微程序CU设计 指…
阅读更多...
使用代理IP时的并发请求是什么意思？

使用代理IP时的并发请求是什么意思？

很多做过数据采集的技术们应该都有所了解，在选择代理IP时会有一个并发请求的参数，这个参数是什么意思呢？可能有很多新手不是很了解，其实代理IP的并发请求就是指同时发送多个请求到目标服务器，以提高请求的效率和速度。…
阅读更多...
嵌入式系统挑战赛题目---递归方法实现字符串反转函数

嵌入式系统挑战赛题目---递归方法实现字符串反转函数

一、题目要求 递归函数是一种在函数内容调用自身的函数。它通过将复杂的问题分解成更小的子问题来解决。递归函数通常包含两部分：基本情况和递归调用。请使用递归方法实现字符串反转的C语言函数。 请根据要求在begin、end间完成代码，不要改变代码中其他…
阅读更多...
开具实习证明：在线实习项目介绍

开具实习证明：在线实习项目介绍

大数据在线实习项目，是在线上为学生提供实习经验的项目。我们希望能够帮助想要在毕业后从事数据科学类工作的学生更加顺利地适应从教室到职场的转换；也帮助那些在工作中需要处理数据、实现数据价值的其他职能的从业者高效快速地掌握每天都能用起来的数据…
阅读更多...
3、Kafka 线上集群部署方案怎么做？

3、Kafka 线上集群部署方案怎么做？

文章目录 1、操作系统的选择1.1、I/O 模型的使用1.2、数据网络传输效率1.3、社区支持度 2、磁盘的选择3、磁盘容量的规划3.1、举例思考本问题：3.2、计算一下：3.3、规划磁盘容量时你需要考虑下面这几个元素： 4、带宽规划4.1、计算 总结 1、操作…
阅读更多...
CSS基础面试题

CSS基础面试题

介绍一下标准css盒子模型与低版本IE的盒子模型？ 标准盒子模型：宽度内容的宽度（content） border padding margin 低版本IE盒子模型：宽度内容宽度（contentborderpadding） margin box-sizing 属性…
阅读更多...
Java架构师-数据机构与算法实战（第一篇）

Java架构师-数据机构与算法实战（第一篇）

数学知识回顾 指数 指数函数是重要的基本初等函数之一。一般地，ya^x函数(a为常数且以a>0，a≠1)叫做指数函数，函数的定义域是 R 。注意，在指数函数的定义表达式中，在a^x前的系数必须是数1，自变量x必须在…
阅读更多...
网易市值超过美团成为中国市值第四大互联网公司 ｜魔法半周报

网易市值超过美团成为中国市值第四大互联网公司 ｜魔法半周报

我有魔法✨为你劈开信息大海❗ 高效获取AIGC的热门事件🔥，更新AIGC的最新动态，生成相应的魔法简报，节省阅读时间👻 🔥资讯预览 网易市值超过美团成为中国市值第四大互联网公司 百度文心一言插件商城正式上…
阅读更多...
SQL数列

SQL数列

SQL数列 1、数列概述2、SQL数列2.1、简单递增序列2.2、等差数列2.3、等比数列3、SQL数列的应用3.1、连续问题3.2、多维分析1、数列概述 数列是最常见的数据形式之一，实际数据开发场景中遇到的基本都是有限数列。常见的数列例如：简单递增序列、等差数列、等比数列等 SQL如何实…
阅读更多...
lv12 交叉开发环境搭建 3

lv12 交叉开发环境搭建 3

1 ubuntu网络环境配置 目的：让Ubuntu可以上外网，让开发板可以与ubuntu互通 2 tftp 服务器环境搭建 tftp（Trivial File Transfer Protocol）即简单文件传输协议 是TCP/IP协议族中的一个用来在客户机与服务器之间进行简单文件 传输…
阅读更多...
PaddleClas学习3——使用PPLCNet模型对车辆朝向进行识别（c++）

PaddleClas学习3——使用PPLCNet模型对车辆朝向进行识别（c++）

使用PPLCNet模型对车辆朝向进行识别 1 准备环境2 准备模型2.1 模型导出2.2 修改配置文件 3 编译3.1 使用CMake生成项目文件3.2 编译3.3 执行3.4 添加后处理程序3.4.1 postprocess.h3.4.2 postprocess.cpp3.4.3 在cls.h中添加函数声明3.4.4 在cls.cpp中添加函数定义3.4.5 在main…
阅读更多...
邮件群发平台推荐：提升邮件营销效果的关键

邮件群发平台推荐：提升邮件营销效果的关键

邮件群发平台是外贸、跨境电商、出海企业常用的一种营销方式。他以低成本、高投资回报比获得了众多企业的青睐。现市场上有各种功能各异、价格不同的邮件群发平台，企业在抉择的时候也会犯难。所以，邮件群发平台哪个好用呢？Zoho Campaigns就是…
阅读更多...
Vue3-11- 【v-for】循环数组

Vue3-11- 【v-for】循环数组

v-for的基本介绍 v-for 是一个指令&#xff0c; 它是用来在 html 模板中实现循环的。它可以循环 普通的数组、也可以直接循环一个范围值&#xff0c;也可以循环对象的每个属性。v-for 的语法介绍 <div v-for"(item,index) in arrayName" : key"index"…
阅读更多...
lua安装

lua安装

lua安装 1.Lua介绍 特点&#xff1a;轻量、小巧。C语言开发。开源。 设计的目的&#xff1a;嵌入到应用程序当中&#xff0c;提供灵活的扩展和定制化的功能。 luanginx&#xff0c;luaredis。 2.windows安装lua windows上安装lua&#xff1a; 检查机器上是否有lua C:\U…
阅读更多...
scala笔记

scala笔记

函数字面量 字面量包括整形字面量、浮点数子面量、布尔型字面量、字符字面量、字符串字面量、符号字面量、函数字面量和元组字面量 除了函数字面量我们比较陌生以外&#xff0c;其他几种字面量都很容易理解 val counter: Int > Int {(value) > value 1}匿名函数 val…
阅读更多...
UE4/UE5 日志插件（基于spdlog）

UE4/UE5 日志插件（基于spdlog）

1 解决问题 对于高频日志序列化到本地的需求&#xff0c;spdlog肯定完美满足。 源码地址&#xff1a;https://github.com/gabime/spdlog 博主下载的版本为 spdlog-1.12.0&#xff0c;各位大佬可以根绝自己爱好选择。 2 过程介绍 大概目录&#xff1a; SpdlogLibC目录下是对…
阅读更多...
牛客网SQL训练3—SQL必知必会

牛客网SQL训练3—SQL必知必会

文章目录 一、检索数据二、排序检索数据三、过滤数据四、高级数据过滤五、用通配符进行过滤六、创建计算字段七、使用函数处理数据八、汇总数据九、分组数据十、使用子查询十一、联结表十二、创建高级联结十三、组合查询 一、检索数据 【题目1&#xff1a;从 Customers 表中检…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023