【linux】多线程控制详述

文章目录

  • 一、进程控制
    • 1.1 POSIX线程库
    • 1.2 创建线程pthread_create
      • 1.2.1 创建一批线程
    • 1.3 终止线程pthread_exit
    • 1.4 线程等待pthread_jion
      • 1.4.1 线程的返回值（退出码）
    • 1.5 取消线程pthread_cancel
    • 1.6 C++多线程
    • 1.7 分离线程pthread_detach
  • 二、线程ID值
  • 三、线程局部存储__thread
  • 四、原生线程库的封装

一、进程控制

1.1 POSIX线程库

这是由原生线程库提供的，遵守POSIX标准。这个标准就像前面学过的system V标准。
有以下特点：

1️⃣ 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以pthread_打头的。
2️⃣ 要使用这些函数库，要通过引入头文<pthread.h>。
3️⃣ 链接这些线程函数库时要使用编译器命令的-lpthread选项。

1.2 创建线程pthread_create

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);
Compile and link with -pthread.// 链接的时候必须加上-lpthread

RETURN VALUE
On success, pthread_create() returns 0; 
on error, it returns an error number, and the contents of *thread are undefined.

参数说明：
thread：线程id
attr：线程属性，直接设为null
start_routine：函数指针
arg：这个参数会传递进start_routine的void*参数中。

这里在链接的时候要注意link到系统给的原生线程库-lpthread。

对于错误的检查：
像我们以前的函数基本都是设置进全局变量errno来指示错误，而pthreads函数出错时不会设置全局变量errno，因为全部变量会被多个线程共享。它会将错误代码通过返回值返回。

1.2.1 创建一批线程

#include <iostream>
#include <string>
#include <pthread.h>
#include <vector>
#include <unistd.h>

using std::cout;
using std::endl;

void* start_stream(void* str)
{
    std::string name = static_cast<const char*>(str);
    while(true)
    {
        cout << "i am new thread: " << name << endl;
        sleep(1);
    }
}

#define NUM 10

int main()
{
    // 创建一批线程
    for(int i = 0; i < NUM; i++)
    {
        pthread_t tid;
        pthread_create(&tid, nullptr, start_stream, (void*)"new thread");
    }

    // 创建完毕
    while(true)
    {
        cout << "-----------create success-----------" << endl;
        sleep(1);
    }
    return 0;
}

在这里插入图片描述
在这里插入图片描述
现在我们给每个线程传递进去的时候加上一个编号：

for(int i = 1; i <= NUM; i++)
{
    pthread_t tid;
    char buf[64];
    snprintf(buf, sizeof(buf), "%s:%d", "thread", i);
    pthread_create(&tid, nullptr, start_stream, (void*)buf);
}

在这里插入图片描述
为什么会出现这个现象呢？
在这里插入图片描述
那么真正的写法应该是什么呢？
我们主要目的是让每个线程都不会共享buf。

class ThreadData
{
public:
    pthread_t _tid;
    char _buf[64];
};

void* start_stream(void* args)
{
    ThreadData *ptd = static_cast<ThreadData *>(args);
    while(true)
    {
        cout << "i am new thread: " << ptd->_buf << endl;
        sleep(1);
    }
}

#define NUM 10

int main()
{
    // 创建一批线程
    for(int i = 1; i <= NUM; i++)
    {
        ThreadData *ptd = new ThreadData();
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
    }

    // 创建完毕
    while(true)
    {
        cout << "-----------create success-----------" << endl;
        sleep(1);
    }
    return 0;
}

这样每个线程所获得的buf都是不同的。
在这里插入图片描述
再加上一个计数器：

void* start_stream(void* args)
{
    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        // cout << "i am new thread: " << ptd->_buf << " cnt: " << cnt << endl;
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    }
    delete ptd;
    return nullptr;
}

在这里插入图片描述
这里可以看到每个线程cnt的地址都不一样，所以每个线程都有不同的cnt，不会相互影响。
这就证明了每一个线程都有自己独立的栈结构。
这个调用方法函数就是一个可重入函数，每个线程都会形成独立的栈帧。

1.3 终止线程pthread_exit

首先要知道最基本的终止方法：
在这里插入图片描述
这里要注意exit不能用来终止线程，使用exit整个进程都会退出，所以exit是用来终止进程的。

POSIX线程库专门给了一个接口用来结束终止线程。

#include <pthread.h>

void pthread_exit(void *retval);

Compile and link with -pthread.

参数可以默认设置为nullptr。

void* start_stream(void* args)
{
    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    }
    delete ptd;
    //return nullptr;
    pthread_exit(nullptr);// 结束线程
}

在这里插入图片描述
可以看到把新建线程结束后，主线程还在继续运行。
当然也可以使用return来终止。

1.4 线程等待pthread_jion

跟进程一样线程也是要等待的，如果不等待，就会造成内存泄漏（类似僵尸进程）。
而等待主要是要做：

  • 获取新线程的退出信息。
  • 回收新线程对应的PCB等内核资源，防止内存泄漏。
#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

Compile and link with -pthread.

RETURN VALUE
On success, pthread_join() returns 0; 
on error, it returns an error number.

参数说明：

thread：要等待的线程。
retval：后面1.4.1线程的返回值详细说明。

class ThreadData
{
public:
    pthread_t _tid;
    char _buf[64];
};

void* start_stream(void* args)
{
    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    }
    delete ptd;
    // return nullptr;
    pthread_exit(nullptr);// 结束线程
}

#define NUM 10

int main()
{
    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    {
        ThreadData *ptd = new ThreadData();
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    }
    for(auto& e : tids)
    {
        printf("creat thread: %s : 0x%x success\n", e->_buf, e->_tid);
    }
    return 0;
}

这是没有等待线程的代码
在这里插入图片描述
可以看到主线程运行完就直接结束了进程，所有新线程也全部结束。

进行线程等待的代码：

class ThreadData
{
public:
    pthread_t _tid;
    char _buf[64];
};

void* start_stream(void* args)
{
    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 5;
    while(cnt)
    {
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    }
    // return nullptr;
    pthread_exit(nullptr);// 结束线程
}

#define NUM 10

int main()
{
    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    {
        ThreadData *ptd = new ThreadData();
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    }
    for(auto& e : tids)
    {
        printf("creat thread: %s : 0x%x success\n", e->_buf, e->_tid);
    }
    // 线程等待
    for(auto& e : tids)
    {
        int n = pthread_join(e->_tid, nullptr);
        assert(n == 0);
        delete e;
    }
    cout << "main thread quit" << endl;
    return 0;
}

在这里插入图片描述
可以看到新线程也都执行到了结尾。

1.4.1 线程的返回值（退出码）

在这里插入图片描述
这里的返回值究竟是干什么的呢？
在这里插入图片描述

这样我们就可以在pthread_jion的时候来获取线程结束的返回值。

class ThreadData
{
public:
    int _number;
    pthread_t _tid;
    char _buf[64];
};

void* start_stream(void* args)
{
    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 5;
    while(cnt)
    {
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    }
    // return nullptr;
     pthread_exit((void*)ptd->_number);// 结束线程
}

#define NUM 10

int main()
{
    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    {
        ThreadData *ptd = new ThreadData();
        ptd->_number = i;
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    }
    for(auto& e : tids)
    {
        printf("creat thread: %s : 0x%x success\n", e->_buf, e->_tid);
    }
    // 线程等待
    for(auto& e : tids)
    {
        void* ret = nullptr;
        int n = pthread_join(e->_tid, &ret);
        assert(n == 0);
        printf("join success: %d\n", (long long)(ret));
        delete e;
    }
    cout << "main thread quit" << endl;
    return 0;
}

在这里插入图片描述
可以看到拿到了返回值（退出码）。

那么这个ret是怎么拿到数据的呢？

线程结束时会把返回值写入pthread库暂时保存，这时候其实我们设置的ret变量类型和库中临时保存的类型相同，但是由于这是个函数调用，我们没办法直接赋值。
在这里插入图片描述
所以我们吧ret的地址传进去，函数内部自己帮我们实现（蓝色）
在这里插入图片描述

这里我们思考一个问题：线程退出的时候为什么没有跟进程退出那样有退出信号？

因为信号是发给进程的，整个进程都会被退出，要退出信号也没有意义了。
所以pthread_jion默认认为能够调用成功，不考虑异常问题，异常应该是进程考虑的问题。

1.5 取消线程pthread_cancel

想要取消线程的前提是线程得先跑起来。

#include <pthread.h>

int pthread_cancel(pthread_t thread);

Compile and link with -pthread.

RETURN VALUE
On success, pthread_cancel() returns 0; 
on error, it returns a nonzero error number.

我们可以取消一半的线程，观察这一半和剩余一半的区别：

class ThreadData
{
public:
    int _number;
    pthread_t _tid;
    char _buf[64];
};

void* start_stream(void* args)
{
    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 5;
    while(cnt)
    {
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    }
    // return nullptr;
     pthread_exit((void*)100);// 结束线程
}

#define NUM 10

int main()
{
    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    {
        ThreadData *ptd = new ThreadData();
        ptd->_number = i;
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    }
    for(auto& e : tids)
    {
        printf("creat thread: %s : 0x%x success\n", e->_buf, e->_tid);
    }

    // 取消一半的线程
    for(int i = 0; i < tids.size() / 2; i++)
    {
        pthread_cancel(tids[i]->_tid);
    }
    // 线程等待
    for(auto& e : tids)
    {
        void* ret = nullptr;
        int n = pthread_join(e->_tid, &ret);
        assert(n == 0);
        printf("join success: %d\n", (long long)(ret));
        delete e;
    }
    cout << "main thread quit" << endl;
    return 0;
}

在这里插入图片描述

在这里插入图片描述
所以线程如果是被取消的，那么它的退出码是-1。它其实是一个宏：PTHREAD_CANCELED。

1.6 C++多线程

我们可以用C++给我们提供的线程库：

#include <iostream>
#include <thread>
#include <unistd.h>

using std::cout;
using std::endl;



int main()
{
    std::thread t([](){
        while(true)
        {
            cout << "i am new thread" << endl;
            sleep(1);
        };
    });

    while(true)
    {
        cout << "i am main thread" << endl;
        sleep(1);
    }

    t.join();
    return 0;
}

在这里插入图片描述
注意编译的时候得链接-lpthread。
因为任何语言想要在linux中实现多线程，必须要使用pthread库。而我们现在写的C++11中的多线程，本质上就是对pthread库的封装。

在后边会模拟线程库的实现。

1.7 分离线程pthread_detach

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

先写一个正常的创建线程：

#include <iostream>
#include <string>
#include <cstdio>
#include <pthread.h>
#include <unistd.h>

using std::cout;
using std::endl;

std::string GetId(const pthread_t& _id)
{
    char buf[64];
    snprintf(buf, sizeof(buf), " 0x%x", _id);
    return buf;
}

void* start_stream(void* args)
{
    std::string name = static_cast<const char*>(args);
    while(true)
    {
        cout << "i am new thread name: " << name << GetId(pthread_self()) << endl;
        sleep(1);
    }
    pthread_exit(nullptr);
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, start_stream, (void*)"thread one");
    cout << "i am main thread, new id: " << GetId(tid) << endl;
    pthread_join(tid, nullptr);
    return 0;
}

在这里插入图片描述

解释一下这里的pthread_self()，哪个线程调用这个函数，就可以获得该线程的id。

#include <pthread.h>

pthread_t pthread_self(void);

Compile and link with -pthread.

RETURN VALUE
This function always succeeds, returning the calling thread's ID.

而上面我们进过验证看到获取的确实是新线程的id。

有了获取线程id的方法接下来就可以进行线程的分离。

#include <pthread.h>

int pthread_detach(pthread_t thread);

Compile and link with -pthread.

RETURN VALUE
On success, pthread_detach() returns 0; 
on error, it returns an error number.

因为如果一个线程设置了分离，那么这个线程就不能被等待，而如果等待失败，就会返回错误码：

std::string GetId(const pthread_t& _id)
{
    char buf[64];
    snprintf(buf, sizeof(buf), " 0x%x", _id);
    return buf;
}

void* start_stream(void* args)
{
    std::string name = static_cast<const char*>(args);
    pthread_detach(pthread_self());// 线程分离
    int cnt = 5;
    while(cnt--)
    {
        cout << "i am new thread name: " << name << GetId(pthread_self()) << endl;
        sleep(1);
    }
    pthread_exit(nullptr);
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, start_stream, (void*)"thread one");
    cout << "i am main thread, new id: " << GetId(tid) << endl;
    // 一个线程设置分离状态就不能被等待了
    int n = pthread_join(tid, nullptr);
    cout << "error: " << n << "->" << strerror(n) << endl;
    return 0;
}

在这里插入图片描述
但是这里的结果显示是正确的。是什么原因呢？

因为主线程和新线程执行顺序不确定，新线程还没来得及分离，主线程就执行到jion了，主线程就开始阻塞等待了，后续新线程分离了也不知道。

所以我们让主线程慢一点执行或者让主线程进行分离：
在这里插入图片描述
在这里插入图片描述
所以一旦有一个线程被分离，那么我们就可以不用管这个线程了，做自己的事情即可。

二、线程ID值

我们可以看到我们打印出来的线程ID：
在这里插入图片描述
那么它究竟是什么呢？

我们知道linux创建进程要通过pthread库提供的接口。所以原生库中可能存在多个线程，那么我们就必须要把这些线程管理起来。而描述这些线程的结构体是由原生线程库实现的，每一个结构体对应一个轻量级进程，所以线程是由库和OS共同实现的。

在这里插入图片描述
而库中描述线程的结构体到底是什么样子的呢？
在这里插入图片描述
每个结构体在库中就像一个数组一样被存储起来。而每个结构体的起始位置的地址就是线程的ID值。
这里也可以看到每个线程都有自己独立的栈结构，由库来维护。

主线程也有自己独立的栈：
在这里插入图片描述

三、线程局部存储__thread

int g_val = 0;

void* start_stream(void* args)
{
    std::string name = static_cast<const char *>(args);
    while(true)
    {
        cout << name;
        printf(" g_val: %d &g_val 0x%x\n", g_val, &g_val);
        sleep(1);
        ++g_val;
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, start_stream, (void*)"thread one");
    while(true)
    {
        printf("main g_val: %d &g_val 0x%x\n", g_val, &g_val);
        sleep(1);
    }
    pthread_join(tid, nullptr);
    return 0;
}

在这里插入图片描述
可以看到不同的线程共享一个全局变量。

但是当我们给g_val添加__thread属性后：
在这里插入图片描述

在这里插入图片描述
从结果看g_val不是共享的了，而是每个线程独有一个。
添加__thread，可以将一个内置类型设置为线程局部存储。给每个线程都来一份。
是介于全局变量和局部变量之间线程特有的属性。

四、原生线程库的封装

我们想像1.6C++多线程那样来使用多线程该怎么办呢？
当然是对原生线程库进行封装。

// mythread.hpp
#pragma once

#include <iostream>
#include <pthread.h>
#include <cstring>
#include <string>
#include <cassert>
#include <functional>

class Thread;

class Context
{
public:
    Thread *_this;
    void *_args;

    Context()
        : _this(nullptr)
        , _args(nullptr)
    {}
};

class Thread
{
public:
    typedef std::function<void*(void*)> func_t;

    Thread(func_t fun, void* args, int number)
        : _func(fun)
        , _args(args)
    {
        char buf[64];
        snprintf(buf, sizeof buf, "thread-%d", number);
        _name = buf;
    }

    // 不加static就会有this指针
    static void* start_routine(void* args)
    {
        //return _func(args);
        // 无this指针，无法调用
        Context* pct = static_cast<Context*>(args);
        pct->_this->_func(pct->_args);
        delete pct;
        return nullptr;
    }

    void start()
    {
        // int n = pthread_create(&_tid, nullptr, _func, _args);
        // _func是C++函数，pthread_create是C接口，不能混编
        Context* pct = new Context();
        pct->_this = this;
        pct->_args = _args;
        int n = pthread_create(&_tid, nullptr, start_routine, pct);
        assert(n == 0);
        (void)n;
    }

    void join()
    {
        int n = pthread_join(_tid, nullptr);
        assert(n == 0);
        (void)n;
    }
private:
    std::string _name;// 线程名
    pthread_t _tid;// 线程id
    func_t _func;// 调用方法
    void *_args;// 参数
};

// mythread.cc
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
#include "mythread.hpp"

using std::cout;
using std::endl;

void* start_handler(void* args)
{
    std::string name = static_cast<const char *>(args);
    while(true)
    {
        cout << name << endl;
        sleep(1);
    }
}

int main()
{
    Thread* thread1 = new Thread(start_handler, (void*)"thread one", 1);
    Thread* thread2 = new Thread(start_handler, (void*)"thread two", 2);
    Thread* thread3 = new Thread(start_handler, (void*)"thread three", 3);
    thread1->start();
    thread2->start();
    thread3->start();
    thread1->join();
    thread2->join();
    thread3->join();
    return 0;
}

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

C/C++内存管理

C/C++内存管理

内存管理在C中无处不在&#xff0c;内存泄漏几乎在每个C程序中都会发生。因此&#xff0c;要学好C&#xff0c;内存管理这一关势在必得&#xff01; 目录 1.C/C内存分布 2.C语言中动态内存管理方式 3.C内存管理方式 3.1.new和delete操作内置类型 3.2.new和delete操作自定义类型…
阅读更多...
SQL注入之HTTP请求头注入

SQL注入之HTTP请求头注入

Ps&#xff1a; 先做实验&#xff0c;在有操作的基础上理解原理会更清晰更深入。 一、实验 sqli-lab 1. User-Agent注入 特点&#xff1a;登陆后返回用户的 User-Agent --> 服务器端可能记录用户User-Agent 输入不合法数据报错 payload: and updatexml(1,concat("~&…
阅读更多...
异或相关算法

异或相关算法

文章目录1. 异或的性质2. 题目一3. 题目二4. 题目三5. 题目四1. 异或的性质 我们知道&#xff0c;异或的定义是&#xff1a;相同为0&#xff0c;相异为1。所以也被称为无进位相加&#xff0c;根据这定义&#xff0c;我们可以得出三个性质&#xff1a; 1. N ^ N0。2. N ^ 0N。3…
阅读更多...
13-C++面向对象(纯虚函数（抽象类）、多继承、多继承-虚函数、菱形继承、虚继承、静态成员)

13-C++面向对象(纯虚函数（抽象类）、多继承、多继承-虚函数、菱形继承、虚继承、静态成员)

虚析构函数 存在父类指针指向子类对象的情况&#xff0c;应该将析构函数声明为虚函数&#xff08;虚析构函数&#xff09; 纯虚函数 纯虚函数&#xff1a;没有函数体且初始化为0的虚函数&#xff0c;用来定义接口规范 抽象类&#xff1a; 含有纯虚函数的类&#xff0c;不可以实…
阅读更多...
Prometheus监控实战系列十七：探针监控

Prometheus监控实战系列十七：探针监控

目前对于应用程序的监控主要有两种方式&#xff0c;一种被称为白盒监控&#xff0c;它通过获取目标的内部信息指标&#xff0c;来监控目标的状态情况&#xff0c;我们前面介绍的主机监控、容器监控都属于此类监控。另一种则是“黑盒监控”&#xff0c;它指在程序外部通过探针的…
阅读更多...
【Linux】Linux下权限的理解

【Linux】Linux下权限的理解

前言&#xff1a;在之前我们已经对基本的指令进行了深入的学习&#xff0c;接下来我将带领大家学习的是关于权限的相关问题。在之前&#xff0c;我们一直是使用的【root】用户&#xff0c;即为“超级用户”&#xff0c;通过对权限的学习之后&#xff0c;我们就会慢慢的切换到普…
阅读更多...
【数据结构】双向链表实现

【数据结构】双向链表实现

Yan-英杰的主页 悟已往之不谏 知来者之可追 C程序员&#xff0c;2024届电子信息研究生 目录 一、什么是双向链表 二、双向链表的实现 一、什么是双向链表 双向链表也叫双链表&#xff0c;是链表的一种&#xff0c;它的每个数据节点中都有两个指针&#xff0c;分别指向直接后…
阅读更多...
【数据结构初阶】单链表

【数据结构初阶】单链表

目录一、思路>>>>>>>>>>>>过程<<<<<<<<<<<<<<<1.打印2.尾插3.尾删4.头插5.头删6.查找7.指定位置后插入8.指定位置后删除9.链表的销毁二、整个程序1.SLTlist.c2.SLTlist.c一、思路 #define …
阅读更多...
点云可视化：使用open3d实现点云连续播放

点云可视化：使用open3d实现点云连续播放

模型训练完成后除了看ap等定量的指标是否变好外，还需要将结果可视化出来，直接观察模型的输出结果，往往我们的数据会比较多，如果单帧的看的话会比较麻烦，需要频繁的关闭窗口，最好是能直接连续的播放数据和模型的推理结果。有三种方法： clear_geomotry()和update_render()…
阅读更多...
SpringBoot 解决id使用字符串类型可以解决精度问题

SpringBoot 解决id使用字符串类型可以解决精度问题

1. 问题引入 当主键超过19位长度的数值型的属性值后三位会被四舍五入 2. 使用雪花算法解决 雪花算法长度最大只有19位的10进制&#xff0c;所以不会丢失精度问题&#xff01;SpringBoot 解决主键雪花算法配置https://liush.blog.csdn.net/article/details/129779627 ① appli…
阅读更多...
Linux的基础知识

Linux的基础知识

根目录和家目录根目录&#xff1a;是Linux中最底层的目录&#xff0c;用"/"表示家目录&#xff1a;当前用户所在的路径&#xff0c;用“~”表示&#xff0c;root用户的家目录和普通用户的家目录不一样&#xff0c;普通用户的家目录在/home路径下&#xff0c;每一个用…
阅读更多...
eNSP 网络地址转换配置实验

eNSP 网络地址转换配置实验

关于本实验当使用私有IP地址的内部主机访问外网时&#xff0c;需要使用NAT将其私有IP地址转换为公有IP地址&#xff0c;此时需要在网关路由器上配置NAT来提供相应的地址转换服务。当网关路由器连接ISP的接口上未使用固定IP地址&#xff0c;而是动态地从ISP获取IP地址时&#xf…
阅读更多...
沁恒CH32V307使用记录：SPI基础使用

沁恒CH32V307使用记录：SPI基础使用

文章目录目的基础说明使用演示其它补充总结目的 SPI是单片机中比较常用的一个功能。这篇文章将对CH32V307中相关内容进行说明。 本文使用沁恒官方的开发板 &#xff08;CH32V307-EVT-R1沁恒RISC-V模块MCU赤兔评估板&#xff09; 进行演示。 基础说明 SPI的基础概念见下面文…
阅读更多...
【Docker】之docker-compose的介绍与命令的使用

【Docker】之docker-compose的介绍与命令的使用

&#x1f341;博主简介 &#x1f3c5;云计算领域优质创作者   &#x1f3c5;华为云开发者社区专家博主   &#x1f3c5;阿里云开发者社区专家博主 &#x1f48a;交流社区&#xff1a;运维交流社区 欢迎大家的加入&#xff01; 文章目录docker-compose简介docker-compose基础…
阅读更多...
C++中的list类【详细分析及模拟实现】

C++中的list类【详细分析及模拟实现】

list类 目录list类一、list的介绍及使用1、构造器及其它重点①遍历②插入删除操作③insert和erase④resize2、Operations接口①remove②sort③merge3、vector与list排序性能比较二、list的深度剖析及模拟实现1、结点的定义2、创建list类3、list类方法的实现3.1 迭代器类的实现*…
阅读更多...
【机器学习面试总结】————特征工程

【机器学习面试总结】————特征工程

【机器学习面试总结】————特征工程一、特征归一化为什么需要对数值类型的特征做归一化?二、类别型特征在对数据进行预处理时,应该怎样处理类别型特征?三、高维组合特征的处理什么是组合特征?如何处理高维组合特征?四、组合特征怎样有效地找到组合特征?五、文本表示模型…
阅读更多...
STM32 10个工程篇：1.IAP远程升级（二）

STM32 10个工程篇：1.IAP远程升级（二）

一直提醒自己要更新CSDN博客&#xff0c;但是确实这段时间到了一个项目的关键节点&#xff0c;杂七杂八的事情突然就一涌而至。STM32、FPGA下位机代码和对应Labview的IAP升级助手、波形设置助手上位机代码笔者已经调试通过&#xff0c;因为不想去水博客、凑数量&#xff0c;复制…
阅读更多...
基于51单片机的室内湿度加湿温度声光报警智能自动控制装置设计

基于51单片机的室内湿度加湿温度声光报警智能自动控制装置设计

wx供重浩&#xff1a;创享日记 对话框发送&#xff1a;单片机湿度 获取完整无水印论文报告&#xff08;内含电路原理图和源程序代码&#xff09; 在日常生活中加湿器得到了广泛的应用&#xff0c;但是现有的加湿器都需要手工控制开启和关闭并且不具备对室内空气温湿度的监测&am…
阅读更多...
【微信小程序】-- 页面导航 -- 编程式导航（二十三）

【微信小程序】-- 页面导航 -- 编程式导航（二十三）

&#x1f48c; 所属专栏&#xff1a;【微信小程序开发教程】 &#x1f600; 作  者&#xff1a;我是夜阑的狗&#x1f436; &#x1f680; 个人简介&#xff1a;一个正在努力学技术的CV工程师&#xff0c;专注基础和实战分享 &#xff0c;欢迎咨询&#xff01; &…
阅读更多...
堆及其多种接口与堆排序的实现

堆及其多种接口与堆排序的实现

我们本期来讲解堆结构 目录 堆的结构 堆的初始化 堆的销毁 堆的插入 向上调整算法 堆的删除 向下调整算法 取堆顶元素 判断堆是否为空 堆中元素个数 堆排序 向下调整与向上调整效率计算 Top-K问题 全部代码 堆的结构 堆是一种用数组模拟二叉树的结构 逻辑结构是…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站