【Linux】从零开始认识多线程 --- 线程控制

在这里插入图片描述

在这个浮躁的时代
只有自律的人才能脱颖而出
-- 《觉醒年代》

从零开始认识多线程 --- 线程控制

  • 1 知识回顾
  • 2 线程控制
    • 2.1 线程创建
    • 2.2 线程等待
    • 2.3 线程终止
  • 3 测试运行
    • 3.1 小试牛刀 --- 创建线程
    • 3.2 探幽析微 --- 理解线程参数
    • 3.3 小有心得 --- 探索线程返回
    • 3.4 求索无厌 --- 实现多线程
    • 3.5 返璞归真 --- 线程终止与线程分离
  • 4 语言层的线程封装
  • Thanks♪(･ω･)ﾉ谢谢阅读！！！
  • 下一篇文章见！！！

1 知识回顾

上一篇文章中，我们通过对地址空间的再次学习来认识了线程：

  1. 物理空间不是连续的，是4kb的内存块（页框）组成的。
  2. 页表映射是通过虚拟地址来索引物理地址：
    • 虚拟地址共32位：前10位用来索引页目录中的元素（页表），中间10位用来索引页表中的对应的元素（页框），后12位用来索引页框中的每一个字节
  3. 虚拟地址本质是一种资源，可以进行分配！对一个进程的数据进行分配执行，就是多线程的本质！
  4. Linux中的线程是通过进程模拟的（并没有单独设计出一个单独的线程模块）
  5. 进程中可以有多个进程（之前学习的是进程的特殊情况），他们共用一个地址空间。进程从内核来看，是承担分配系统资源的基本实体！
  6. Linux中的执行流是线程 ，CPU看到的执行流 <= 进程

进程与线程需要注意：

  1. 线程的调度成本比进程低很多，是由于硬件原因：CPU中存在一个cache会储存热点数据（进程相关数据） ，要访问数据时，会先在cache中寻找，如果命中直接访问，反之进行置换。切换进程需要更换热点数据，切换线程不需要切换。
  2. 线程的健壮性很差！一个线程出错会导致整个线程退出，而不同进程是独立的互不影响！进程和线程各有特长！
  3. 线程的本质是代码块！只使用函数的对应代码，即拿页表的一部分来执行！！！
  4. 线程的使用场景多为计算密集型和IO密集型，可以充分使用CPU的并行能力！

同一个进程中的线程虽然共享一个地址空间，但是还是有独属于自己的一些东西：

  1. 一组寄存器：在硬件中储存上下文数据，保证线程可以动态并行运行！
  2. 栈空间：线程中可以处理自己的临时变量，临时变量储存在自己独立的栈区，可以独立完成任务。
  3. 线程ID
  4. errno信号屏蔽字
  5. 调度优先级

复习的差不多了，我们了解了线程的基本概念，接下来就要开始学习如何管理线程 — 线程控制。根据我们之前学习的进程控制，大概可以估计一下线程控制的基本接口：线程创建 ， 线程等待 ， 线程退出…

2 线程控制

2.1 线程创建

万事开头难，我们先来看线程怎么创建：

PTHREAD_CREATE(3)                                                   Linux Programmer's Manual                                                  PTHREAD_CREATE(3)

NAME
       pthread_create - create a new thread

SYNOPSIS
       #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.

pthread_create是创建线程的接口，里面有4个参数:

  1. pthread_t *thread :输出型参数，线程ID。
  2. const pthread_attr_t *attr ：线程属性（优先级，上下文…），默认传入nullptr
  3. void *(*start_routine) (void *) : 函数指针，线程需要执行的函数地址。
  4. void arg：想要传入到线程的信息，可以传入int，string地址或者传入一个类对象的地址。

再来看返回值：

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

pthread系列的函数的返回值是都是一样的：成功返回0，反之返回错误码！

2.2 线程等待

学习进程的时候，如果进程创建出来了，但是不进行等待，就拿不到退出信息，还会造成僵尸进程，进而造成内存泄漏。同样线程也需要进行等待。由主线程来等待新线程

PTHREAD_JOIN(3)                                                     Linux Programmer's Manual                                                    PTHREAD_JOIN(3)

NAME
       pthread_join - join with a terminated thread

SYNOPSIS
       #include <pthread.h>

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

       Compile and link with -pthread.

这个函数里面有2个参数：

  1. pthread_t thread：需要进行等待的线程ID
  2. void **retval: 获取的返回信息

2.3 线程终止

牢记：main线程结束那么进程结束，所以一定要保证main线程最后退出。

  1. 最简单的线程终止是线程函数返回return ！
  2. 切记不要使用exit()，我们在进程控制中学习过exit()可以退出进程，但是要注意线程是在一个进程中讨论的，新线程如果使用了exit()那整个进程就退出了！exit()不可以用来终止线程
  3. 操作系统也给我们提供了线程终止的接口：
PTHREAD_CANCEL(3)                                                   Linux Programmer's Manual                                                  PTHREAD_CANCEL(3)

NAME
       pthread_cancel - send a cancellation request to a thread

SYNOPSIS
       #include <pthread.h>

       int pthread_cancel(pthread_t thread);

       Compile and link with -pthread.

通过这个参数，可以看出来这是个很简单的接口，终止对应tid的线程。只要线程存在，并且知道tid , 就可以终止线程（可以自己终止自己）。线程终止的返回值是一个整数！

3 测试运行

3.1 小试牛刀 — 创建线程

我们进行一个简单的测试，来使用这两个接口：
注意，使用线程库的接口需要动态链接g++ -o $@ $^ -std=c++11 -lpthread

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

// 测试 1
void *ThreadRun(void *args)
{
    std::cout << "name: " << *(std::string*)args << " is running"<< std::endl;
    sleep(1);
    std::string* ret = new std::string(*(std::string*)args + "finish...") ;

    return (void*)ret;
}

int main()
{
    // 创建一个新线程
    // int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
    pthread_t tid;
    std::string name = "thread - 1";
    pthread_create(&tid, nullptr, ThreadRun, &name);

    //进程等待
    //int pthread_join(pthread_t thread, void **retval);
    std::string *ret = nullptr;
    pthread_join(tid, (void**)&ret);
    std::cout << *(std::string*)ret << std::endl;

    return 0;
}

编译运行一下，我们可以看到：
在这里插入图片描述
新线程完成了任务！

问题 1 ： main线程和new线程谁先运行？ 不确定，和进程的调度方式一致，由具体情况来定。

问题 2 ： 我们期望谁先退出？肯定是main线程，所以就有join来进行等待，阻塞等待线程退出。如果不进行join,就会造成类似僵尸进程的情况（内存泄漏）！

问题 3 ：tid是什么样子的，我们可不可以看一看？当然可以：

std::string ToHex(int x)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", x);
    return buffer;
}

这样就可以打印出来tid的十六进制：
在这里插入图片描述
这数字好像和lwp不一致啊
在这里插入图片描述
为什么tid这么大？其实tid是一个虚拟地址!!!

3.2 探幽析微 — 理解线程参数

问题 4 ： 全面看待线程函数传参。上面我们的程序传入了name变量的地址，让线程获取了对应的名字。如果想要传入多个变量或方法，可以传入类对象的地址:

class ThreadData
{
public:
    std::string name;
    int num;
};
vvoid *ThreadRun(void *args)
{
    ThreadData* td = static_cast<ThreadData*>(args);
    std::cout << "name: " << td->name << " is running" << std::endl;
    std::cout << "num: " << td->num << std::endl; 
    sleep(1);
    std::string *ret = new std::string(*(std::string *)args + "finish...");

    return (void *)ret;
}

std::string ToHex(int x)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", x);
    return buffer;
}

int main()
{
    // 创建一个新线程
    // int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
    pthread_t tid;
    // std::string name = "thread - 1";
    ThreadData td;
    td.name = "thread - 1";
    td.num = 100;
    pthread_create(&tid, nullptr, ThreadRun, &td);

    // 查看tid
    sleep(1);
    std::cout << "tid: " << ToHex(tid) << std::endl;

    // 进程等待
    // int pthread_join(pthread_t thread, void **retval);
    std::string *ret = nullptr;
    pthread_join(tid, (void **)&ret);
    std::cout << *(std::string *)ret << std::endl;

    return 0;
}

这样就可以传入多个变量：
在这里插入图片描述
所以这个void*的变量是可以传入任何地址的，一定要想到可以传入类对象。但是刚写的有些问题，我们上面的写法是在主线程的栈区创建变量，让新线程读取主线程的栈，不太合适（破坏了一定独立性）！如果多个变量都传入了这个变量，那么修改一个就会造成所以的线程中的数据都发生改变！！！这可不行！推荐写：

	ThreadData* td = new ThreadData();
    td->name = "thread - 1";
    td->num = "100";
    pthread_create(&tid, nullptr, ThreadRun, td);

这是在堆区进行开辟空间，然后将该空间交给新线程来管理！就不会出现这样的问题了！以后我们都使用这种方式来传递参数！！！

3.3 小有心得 — 探索线程返回

问题 5 ：线程的返回值输出型参数void** retval,他需要我们传递一个void*变量，然后返回值就交给了void*变量！这个过程就是对一个指针进行改变其指向的内容的操作。

下面是一个让新线程进行加法工作的程序

void *ThreadRun(void *args)
{
    ThreadData* td = static_cast<ThreadData*>(args);
    std::cout << "name: " << td->name << " is running" << std::endl;
    std::cout << "num: " << td->num << std::endl; 
    sleep(1);
    delete td;
    //返回值
    std::string *ret = new std::string(*(std::string *)args + "finish...");
    return (void *)ret;
}

这就将void*变量返回给&（void* ret）变量,让ret指向对应的堆区。这就类似int a放入int * 中就可以改变a的值

问题 5 ：如何全面的看待线程的返回。我们知道如果一个线程出现问题，整个进程就会退出。所以线程的返回只有正常的返回，没有异常的返回，出现异常整个进程会直接退出，根本没有返回错误信息的机会！和传入参数音参数一样，我们也可以返回一个类对象来传递多个变量。

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

// 测试 1
class ThreadData
{
public:
    std::string name;
    int num1;
    int num2;
};

class ThreadResult
{
public:
    std::string name;
    int num1;
    int num2;
    int ans;
};

void *ThreadRun(void *args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    std::cout << "name: " << td->name << " is running" << std::endl;
    std::cout << "num1: " << td->num1 << " num2: " << td->num2 << std::endl;
    sleep(1);

    ThreadResult *ret = new ThreadResult();
    ret->name = td->name;
    ret->num1 = td->num1;
    ret->num2 = td->num2;
    ret->ans = td->num2 + td->num1;

    delete td;
    return (void *)ret;
}

std::string ToHex(int x)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", x);
    return buffer;
}

int main()
{
    // 创建一个新线程
    // int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
    pthread_t tid;
    // std::string name = "thread - 1";
    ThreadData *td = new ThreadData();
    td->name = "thread - 1";
    td->num1 = 100;
    td->num2 = 88;

    pthread_create(&tid, nullptr, ThreadRun, td);

    // 查看tid
    sleep(1);
    std::cout << "tid: " << ToHex(tid) << std::endl;

    // 进程等待
    // int pthread_join(pthread_t thread, void **retval);
    ThreadResult *ret = nullptr;
    pthread_join(tid, (void **)&ret);
    
    std::cout << ret->num1 << " + " << ret->num2 << " = " << ret->ans << std::endl;

    return 0;
}

来看返回值：
在这里插入图片描述
我们成功获取了新线程中设置的返回值！非常nice!

3.4 求索无厌 — 实现多线程

问题 6 ：上面只是创建了单独的一个线程，那如何创建多线程呢？
可以通过维护一个vector数组来对tid进行统一管理

void *ThreadRun(void *args)
{
    std::string name = static_cast<const char *>(args);
    while (true)
    {
        std::cout << name << "is running ..." << std::endl;
        sleep(1);
    }
    return (void *)0;
}

std::string ToHex(int x)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", x);
    return buffer;
}

const int num = 10;

int main()
{
    std::vector<pthread_t> tids;
    for (int i = 0; i < num; i++)
    {
        // 1. 线程ID
        pthread_t tid;
        // 2. 线程名字
        char* name = new char[128];
        snprintf(name, 128, "thread - %d", i + 1);
        pthread_create(&tid, nullptr, ThreadRun, name);
        //保存所有线程的ID
        tids.push_back(tid) ;
    }
    //join
    sleep(100);


    return 0;
}

在这里插入图片描述
这样就创建出了10个新线程，但是我们看这些新线程的的名字好像不太对：
在这里插入图片描述
怎么不是1 - 10???完全是乱的！因为线程谁先被调度运行不确定！而我们传入的名字是在主线程的栈区域，可能在新线程还没有调度，name就已经在主线程中被覆盖了!解决办法很简单，我们创建在堆区就可以了

for (int i = 0; i < num; i++)
    {
        // 1. 线程ID
        pthread_t tid;
        // 2. 线程名字
        //在堆区进行创建。防止被重写覆盖
        char* name = new char[128];
        snprintf(name, 128, "thread - %d", i + 1);
        pthread_create(&tid, nullptr, ThreadRun, name);
        pids.push_back(tid) ;
    }

在这里插入图片描述
这样就整齐多了！

接下来就要进行等待：
我们已经通过vector容器来维护了创建所有线程的tid,所以只需要对所有的tid进行join就好了！

void *ThreadRun(void *args)
{
    std::string name = static_cast<const char *>(args);
    while (true)
    {
        std::cout << name << "is running ..." << std::endl;
        sleep(3);
        break;
    }
    return nullptr;
}

std::string ToHex(int x)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", x);
    return buffer;
}

const int num = 10;

int main()
{
    std::vector<pthread_t> tids;
    for (int i = 0; i < num; i++)
    {
        // 1. 线程ID
        pthread_t tid;
        // 2. 线程名字
        char* name = new char[128];
        snprintf(name, 128, "thread - %d", i + 1);
        pthread_create(&tid, nullptr, ThreadRun, name);
        //保存所有线程的ID
        tids.push_back(tid) ;
    }
    //join
    for (auto tid : tids)
    {
        pthread_join(tid , nullptr);
        std::cout << ToHex(tid) << " quit..." << std::endl;
    }
}

来看运行效果：
在这里插入图片描述
非常好！！！

我们也可以通过返回值来获取线程的名字：

    for (auto tid : tids)
    {
        void* name = nullptr;
        pthread_join(tid , &name);
        std::cout << (const char*)name<< " quit..." << std::endl;
        delete (const char*)name;
    }

非常优雅！
在这里插入图片描述

3.5 返璞归真 — 线程终止与线程分离

问题 7 ：线程终止的返回值
我们来看看通过线程终止接口终止的线程返回值是什么样的：

void *ThreadRun(void *args)
{
    std::string name = static_cast<const char *>(args);
    while (true)
    {
        std::cout << name << "is running ..." << std::endl;
        sleep(3);
        //break;
    }
    return args;
}

std::string ToHex(int x)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", x);
    return buffer;
}

const int num = 10;

int main()
{
    std::vector<pthread_t> tids;
    for (int i = 0; i < num; i++)
    {
        // 1. 线程ID
        pthread_t tid;
        // 2. 线程名字
        char* name = new char[128];
        snprintf(name, 128, "thread - %d", i + 1);
        pthread_create(&tid, nullptr, ThreadRun, name);
        //保存所有线程的ID
        tids.push_back(tid) ;
    }
    //join
    sleep(3);
    
    for (auto tid : tids)
    {
        pthread_cancel(tid);
        std::cout <<  " cancel: " << ToHex(tid) << std::endl;
        void* ret= nullptr;
        pthread_join(tid , &ret);
        std::cout << (long long int)ret << " quit..." << std::endl;

    }

    return 0;
}

在这里插入图片描述
可以看的，被phread_cancel()终止的线程的返回值是 -1!这个 -1其实是宏定义#define PTHREAD_CANCELED ((void *) -1)。线程终止的方式有三种：

  1. 线程函数 return
  2. pthread_cancel 新线程退出结果为-1
  3. pthread_exit

问题 8 ：可不可以不通过join线程，让他执行完就退出呢，当然可以！
这里需要线程分离接口：

PTHREAD_DETACH(3)                                                   Linux Programmer's Manual                                                  PTHREAD_DETACH(3)

NAME
       pthread_detach - detach a thread

SYNOPSIS
       #include <pthread.h>

       int pthread_detach(pthread_t thread);

       Compile and link with -pthread.

通过这个接口，分离出去的线程依然属于进程内部，但不需要被等待了。举个例子，之前再讲线程与进程的关系时，我们把不同的线程比作家庭成员，做好自己分内的事情，既可以让家庭幸福，即进程成功运行。而进程分离就好比你长大了，自己搬出去住，不受父母管了，但是依旧属于这个家庭。这种状态就是线程分离。

当然，如果想要将自己分离出去，就要知道自己的tid,这里需要接口：

PTHREAD_SELF(3)                                                     Linux Programmer's Manual                                                    PTHREAD_SELF(3)

NAME
       pthread_self - obtain ID of the calling thread

SYNOPSIS
       #include <pthread.h>

       pthread_t pthread_self(void);

       Compile and link with -pthread.

这个接口会返回调用它的线程的ID。如同getpid()

void *ThreadRun(void *args)
{
    // 线程分离
    pthread_detach(pthread_self());
    std::string name = static_cast<const char *>(args);
    while (true)
    {
        std::cout << name << "is running ..." << std::endl;
        sleep(3);
        break;
    }
    return args;
}

std::string ToHex(int x)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", x);
    return buffer;
}

const int num = 10;

int main()
{
    std::vector<pthread_t> tids;
    for (int i = 0; i < num; i++)
    {
        // 1. 线程ID
        pthread_t tid;
        // 2. 线程名字
        char *name = new char[128];
        snprintf(name, 128, "thread - %d", i + 1);
        pthread_create(&tid, nullptr, ThreadRun, name);
        // 保存所有线程的ID
        tids.push_back(tid);
    }

    sleep(3);

    for (auto tid : tids)
    {
        pthread_cancel(tid);
        std::cout << " cancel: " << ToHex(tid) << std::endl;
        void *ret = nullptr;
        int n = pthread_join(tid, &ret);
        std::cout << (long long int)ret << " quit... , n: " << n << std::endl;
    }

    return 0;
}

可以看到，如果我们等待一个已经分离出去的线程，会得到22号错误信息！所以不能 join 一个分离的线程！
在这里插入图片描述
所以主线程就可以不管新线程，可以继续做自己的事情，不用阻塞在join!

但是注意：线程分离了，依然是同一个进程！一个线程出异常，会导致整个进程退出！

上面是自己分离自己。也可以通过主线程分离新进程：

    for (auto tid : tids)
    {
        pthread_detach(tid);//主线程分离新线程
    }

4 语言层的线程封装

上面讲的是Linux系统提供给我们的系统调用，帮助我们可以进行线程控制，也叫做原生线程库。我们熟悉了底层的原生线程库，就会方便很多。
我们来看C++11中的线程

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

void threadrun( int num)
{
    while (num)
    {
        std::cout << " num: " << num << std::endl;
    }
}

// C++中线程库
int main()
{
    std::thread mythread(threadrun, 10);

    while (true)
    {
        std::cout << "main thread..." << std::endl;
        sleep(1);
    }
    mythread.join();
    return 0;
}

注意，虽然是使用的语言层的线程库，但是依旧要连接thread动态库,因为语言层线程库的本质是对原生线程库接口的封装！！！无论是java还是python都要与原生线程库产生联系！

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！

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

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

相关文章

CSS技巧专栏：一日一例 2.纯CSS实现 多彩边框按钮特效

CSS技巧专栏：一日一例 2.纯CSS实现 多彩边框按钮特效

大家好，今天是 CSS技巧一日一例 专栏的第二篇《纯CSS实现多彩边框按钮特效》 先看图： 开工前的准备工作 正如昨日所讲，为了案例的表现，也处于书写的习惯，在今天的案例开工前，先把昨天的准备工作重做一遍。 清除浏览器的默认样式定义页面基本颜色设定body的样式清除butt…
阅读更多...
好用的智能模型网站合集——Vol1

好用的智能模型网站合集——Vol1

探秘 AIGC 精彩应用&#xff0c;开启 AI 无限可能 别忘了点赞关注转发&#xff01; openxlab 在线工具合集 大眼仔好用工具合集 扣子——海量ai工具合集
阅读更多...
书生大模型实战营-入门岛-第三关

书生大模型实战营-入门岛-第三关

提交PR 建立仓库 https://github.com/Olive-2019/NL2SQL/tree/main
阅读更多...
算法日常练习

算法日常练习

对于这个题&#xff0c;如何处理同一个方向的问题&#xff0c;且对于同一组的如果间隔太大如何实现离散化 #include<bits/stdc.h> using namespace std;#define int long long typedef long long ll; map<pair<int,int>,vector<pair<ll,ll>>> mp…
阅读更多...
Windows安装adb和常用操作命令

Windows安装adb和常用操作命令

简介 ADB&#xff08;Android Debug Bridge&#xff09;是Android开发者、测试工程师和普通用户在管理、调试、自动化控制Android设备时的重要工具。它提供了丰富的命令集&#xff0c;允许通过命令行接口对Android设备进行各种操作。 下载 https://download.csdn.net/downlo…
阅读更多...
TCA链路聚合技术之手工配置详解

TCA链路聚合技术之手工配置详解

stp端口状态 1. discarding堵塞状态&#xff1a;禁用&#xff0c;堵塞&#xff0c;监听 所有接口初始状态&#xff0c;无法发送数据帧&#xff0c;也无法学习mac地址表&#xff0c;最终只有AP口永久停留该状态。DP和RP会向下一个状态转变&#xff0c; 2、learning学习状态&a…
阅读更多...
【C++进阶学习】第七弹——AVL树——树形结构存储数据的经典模块

【C++进阶学习】第七弹——AVL树——树形结构存储数据的经典模块

二叉搜索树&#xff1a;【C进阶学习】第五弹——二叉搜索树——二叉树进阶及set和map的铺垫-CSDN博客 目录 一、AVL树的概念 二、AVL树的原理与实现 AVL树的节点 AVL树的插入 AVL树的旋转 AVL树的打印 AVL树的检查 三、实现AVL树的完整代码 四、总结 前言&#xff1a…
阅读更多...
2024世界人工智能大会（WAIC）学习总结

2024世界人工智能大会（WAIC）学习总结

1 前言 在2024年的世界人工智能大会&#xff08;WAIC&#xff09;上&#xff0c;我们见证了从农业社会到工业社会再到数字化社会的深刻转变。这一进程不仅体现在技术的单点爆发&#xff0c;更引发了整个产业链的全面突破&#xff0c;未来将是技术以指数级速度发展的崭新时代。…
阅读更多...
21天学通C++：第十一、十二章节

21天学通C++：第十一、十二章节

第十一章&#xff1a;多态 多态基础 多态&#xff08;Polymorphism&#xff09;是面向对象语言的一种特征&#xff0c;让您能够以类似的方式处理不同类似的对象。 有一句话总结的很好&#xff1a;多态其实就是父类型引用指向子类型对象。 为什么需要多态 #include <ios…
阅读更多...
Profibus协议转Profinet协议网关模块连接智能电表通讯案例

Profibus协议转Profinet协议网关模块连接智能电表通讯案例

一、背景 在工业自动化领域&#xff0c;Profibus协议和Profinet协议是两种常见的工业通讯协议&#xff0c;而连接智能电表需要用到这两种协议之间的网关模块。本文将通过一个实际案例&#xff0c;详细介绍如何使用Profibus转Profinet模块&#xff08;XD-PNPBM20&#xff09;实…
阅读更多...
docker 安装 onlyoffice

docker 安装 onlyoffice

1.文档地址 Installing ONLYOFFICE Docs for Docker on a local server - ONLYOFFICE 2.安装onlyoffice docker run -i -t -d -p 9000:8000 --restartalways -e JWT_ENABLEDfalse onlyoffice/documentserver 如果发现镜像无法下载,可以尝试更换镜像源 {"registry-mir…
阅读更多...
wifi信号处理的CRC8、CRC32

wifi信号处理的CRC8、CRC32

&#x1f9d1;&#x1f3fb;个人简介&#xff1a;具有3年工作经验&#xff0c;擅长通信算法的MATLAB仿真和FPGA实现。代码事宜&#xff0c;私信博主&#xff0c;程序定制、设计指导。 &#x1f680;wifi信号处理的CRC8、CRC32 目录 &#x1f680;1.CRC概述 &#x1f680;1.C…
阅读更多...
【链表】算法题（一） ---- 力扣 / 牛客

【链表】算法题（一） ---- 力扣 / 牛客

一、移除链表元素 移除链表中值为val的元素&#xff0c;并返回新的头节点 思路&#xff1a; 题目上这样说&#xff0c;我们就可以创建一个新的链表&#xff0c;将值不为val的节点&#xff0c;尾插到新的链表当中&#xff0c;最后返回新链表的头节点。 typedef struct ListNo…
阅读更多...
[React 进阶系列] useSyncExternalStore hook

[React 进阶系列] useSyncExternalStore hook

[React 进阶系列] useSyncExternalStore hook 前情提要&#xff0c;包括 yup 的实现在这里&#xff1a;yup 基础使用以及 jest 测试 简单的提一下&#xff0c;需要实现的功能是&#xff1a; yup schema 需要访问外部的 storage外部的 storage 是可变的React 内部也需要访问同…
阅读更多...
linux adb命令

linux adb命令

⏩ 大家好哇&#xff01;我是小光&#xff0c;正在努力寻找自己的职业方向。 ⏩ 在调试设备时&#xff0c;经常会用到adb命令&#xff0c;本文对linux adb命令做一个知识分享。 ⏩ 感谢你的阅读&#xff0c;不对的地方欢迎指正。 1.adb命令 即 Android Debug Bridge 是一种允许…
阅读更多...
解决第三方模块ts声明文件缺失的问题

解决第三方模块ts声明文件缺失的问题

最近小卷在用vite脚手架学习vue组件开发&#xff0c;使用的语言框架是typescript。在搭建vitepress在线文档服务时&#xff0c;用到了vitepress-demo-preview模块来展示vue组件示例和源代码。 发现import相关依赖时&#xff0c;会有这样的编译错误&#xff1a; 也就是没找到第…
阅读更多...
Transformer模型：Postion Embedding实现

Transformer模型：Postion Embedding实现

前言 这是对上一篇WordEmbedding的续篇PositionEmbedding。 视频链接&#xff1a;19、Transformer模型Encoder原理精讲及其PyTorch逐行实现_哔哩哔哩_bilibili 上一篇链接&#xff1a;Transformer模型&#xff1a;WordEmbedding实现-CSDN博客 正文 先回顾一下原论文中对Posit…
阅读更多...
张量分解(5)——Tucker分解

张量分解(5)——Tucker分解

&#x1f345; 写在前面 &#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;这里是hyk写算法了吗&#xff0c;一枚致力于学习算法和人工智能领域的小菜鸟。 &#x1f50e;个人主页&#xff1a;主页链接&#xff08;欢迎各位大佬光临指导&#xff09; ⭐️近…
阅读更多...
【C++】构造函数详解

【C++】构造函数详解

&#x1f4e2;博客主页&#xff1a;https://blog.csdn.net/2301_779549673 &#x1f4e2;欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 如有错误敬请指正&#xff01; &#x1f4e2;本文由 JohnKi 原创&#xff0c;首发于 CSDN&#x1f649; &#x1f4e2;未来很长&#…
阅读更多...
【开源 Mac 工具推荐之 1】gibMacOS：方便快捷的 macOS 完整包下载 Shell 工具

【开源 Mac 工具推荐之 1】gibMacOS：方便快捷的 macOS 完整包下载 Shell 工具

简介 gibMacOS 是由 GitHub 开发者 corpnewt 编写的一款 Shell 工具。它采用 Python 编程语言&#xff0c;可以让用户打开后在纯文本页面中轻松选择并下载来源于 Apple 官方的 macOS 完整安装包。 Repo 地址&#xff1a;https://github.com/corpnewt/gibMacOS &#xff08;其…
阅读更多...
最新文章

Copyright @ 2022~2023