Linux之线程池

线程池

  • 线程池概念
  • 线程池的应用场景
  • 线程池实现原理
  • 单例模式下线程池实现
  • STL、智能指针和线程安全
  • 其他常见的各种锁

线程池概念

线程池：一种线程使用模式。

线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。

这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

线程池的应用场景

  1. 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了；
  2. 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求；
  3. 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误。

线程池实现原理

线程池通过一个线程安全的阻塞任务队列加上一个或一个以上的线程实现，线程池中的线程可以从阻塞队列中获取任务进行任务处理，当线程都处于繁忙状态时可以将任务加入阻塞队列中，等到其它的线程空闲后进行处理。
在这里插入图片描述

testMain.cc

主线程任务逻辑启动线程，不断向任务队列中push任务就可以了，此时线程接收到任务就会进行处理：

#include <iostream>
#include <ctime>
#include <unistd.h>
#include "threadPool.hpp"
#include "Task.hpp"
#include "log.hpp"

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid());
    ThreadPool<Task>* tp = new ThreadPool<Task>();

    //启动线程
    tp->run();

    //主线程执行任务
    while(true)
    {
        int x = rand() % 100 + 1;
        usleep(1000);
        int y = rand() % 50 + 1;
        Task t(x, y, [](int x, int y)->int{
            return x + y;
        });

        logMessage(DEBUG, "制作任务完成：%d+%d=?", x, y);
        // std::cout << "制作任务完成: " << x << "+" << y << "=?" << std::endl;

        //将任务推送到线程池中
        tp->pushTask(t);

        sleep(1);
    }
    return 0;
}

thread.hpp

我们对创建线程进行封装，包含线程名，线程个数，回调函数，线程ID等；

#pragma once

#include <iostream>
#include <string>
#include <functional>
#include <cstdio>

typedef void *(*func_t)(void *);

class ThreadData
{
public:
    std::string name_;
    void *args_;
};

class Thread
{
public:
    Thread(int num, func_t callback, void *args) : func_(callback)
    {
        char nameBuffer[64];
        snprintf(nameBuffer, sizeof nameBuffer, "Thread-%d", num);
        name_ = nameBuffer;

        tdata_.args_ = args;
        tdata_.name_ = name_;
    }

    void start()
    {
        pthread_create(&tid_, nullptr, func_, (void *)&tdata_);
    }

    void join()
    {
        pthread_join(tid_, nullptr);
    }

    std::string name()
    {
        return name_;
    }

    ~Thread()
    {
    }

private:
    std::string name_; // 线程名
    int num_;          // 线程个数
    func_t func_;      // 回调函数
    pthread_t tid_;    // 线程ID
    ThreadData tdata_;
};

threadPool.hpp

线程池中我们需要用注意的是：

  1. 需要用到条件变量与互斥锁，因为线程池中的任务队列会被多个执行流访问，所以我们必须引入互斥锁；
  2. 当线程池中任务队列为满时，我们此时push任务就无法push进去，此时就需要挂起等待，直到线程将某一任务执行完毕，唤醒等待队列，才可以继续进行push，我们执行任务也是一样，只有当任务队列中有任务时，我们才可以执行，否则就需要挂起等待，直到有任务生成才去获取任务；
  3. 线程执行例程需要设置为静态方法，原因如下：
  • 使用pthread_create函数创建线程时，需要为创建的线程传入一个routine（执行例程），该routine只有一个参数类型为void的参数，以及返回类型为void的返回值。因为我们将线程池封装为一个类，此时routine函数就包含两个参数，第一个参数就是隐含的this指针，直接用来创建线程程序是会报错的；
  • 静态成员函数属于类，而不属于某个对象，也就是说静态成员函数是没有隐藏的this指针的，因此我们需要将routine设置为静态方法，此时routine函数才真正只有一个参数类型为void*的参数。
  • 但是在静态成员函数内部无法调用非静态成员函数，而我们需要在routine函数当中调用该类的某些非静态成员函数，比如pop。因此我们需要在创建线程时，向routine函数传入的当前对象的this指针，此时我们就能够通过该this指针在routine函数内部调用非静态成员函数了。
#pragma once

#include <iostream>
#include <vector>
#include <queue>
#include <unistd.h>
#include "thread.hpp"
#include "lockGuard.hpp"
#include "log.hpp"

#define NUM 3

template <class T>
class ThreadPool
{
public:
    pthread_mutex_t *getMutex()
    {
        return &lock;
    }

    bool isEmpty()
    {
        return task_queue_.empty();
    }

    void waitCond()
    {
        pthread_cond_wait(&cond, &lock);
    }

    T getTask()
    {
        T t = task_queue_.front();
        task_queue_.pop();
        return t;
    }

public:
    ThreadPool(int thread_num = NUM) : num_(thread_num)
    {
        pthread_mutex_init(&lock, nullptr);
        pthread_cond_init(&cond, nullptr);

        for (int i = 1; i <= num_; i++)
        {
            threads_.push_back(new Thread(i, routine, this));
        }
    }

    // 生产
    void run()
    {
        for (auto &iter : threads_)
        {
            iter->start();
            // std::cout << iter->name() << "启动成功" << std::endl;
            logMessage(NORMAL, "%s %s", iter->name().c_str(), "启动成功");
        }
    }

    static void *routine(void *args)
    {

        ThreadData *td = (ThreadData *)args;
        ThreadPool<T> *tp = (ThreadPool<T> *)td->args_;

        while (true)
        {
            T task;
            {
                LockGuard lockguard(tp->getMutex());

                while (tp->isEmpty())
                    tp->waitCond();

                task = tp->getTask();
            }

            // 处理任务
            task(td->name_);
        }
    }

    void pushTask(const T &task)
    {
        LockGuard lockguard(&lock);
        task_queue_.push(task);
        pthread_cond_signal(&cond);
    }

    ~ThreadPool()
    {
        for (auto &iter : threads_)
        {
            iter->join();
            delete iter;
        }

        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&cond);
    }

private:
    std::vector<Thread *> threads_; // 线程组
    int num_;
    std::queue<T> task_queue_; // 任务队列

    pthread_mutex_t lock; // 互斥锁
    pthread_cond_t cond;  // 条件变量
};

lockGuard.hpp

为了代码更加的模块化，我们将互斥锁进行一个封装成一个RAII风格的锁，创建对象是调用构造函数加锁，出作用域调用析构函数解锁：

#pragma once

#include <iostream>
#include <pthread.h>

class Mutex
{
public:
    Mutex(pthread_mutex_t *mtx) : pmtx_(mtx)
    {
    }

    void lock()
    {
        pthread_mutex_lock(pmtx_);
    }

    void unlock()
    {
        pthread_mutex_unlock(pmtx_);
    }

    ~Mutex()
    {
    }

private:
    pthread_mutex_t *pmtx_;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t* mtx) : mtx_(mtx)
    {
        mtx_.lock();
    }

    ~LockGuard()
    {
        mtx_.unlock();
    }

private:
    Mutex mtx_;
};

Task.hpp

这是一个加法的计算任务：

#pragma once

#include <iostream>
#include <string>
#include <functional>

typedef std::function<int(int, int)> tfunc_t;

class Task
{
public:
    Task()
    {
    }

    Task(int x, int y, tfunc_t func) : x_(x), y_(y), func_(func)
    {
    }

    void operator()(const std::string& name)
    {
        // std::cout << "线程 " << name << " 处理完成, 结果是: " << x_ << "+" << y_ << "=" << func_(x_, y_) << std::endl;
        logMessage(WARNING, "%s处理完成:%d+%d = %d | %s | %d", name.c_str(), x_, y_, func_(x_, y_), __FILE__, __LINE__);
    }

private:
    int x_;
    int y_;
    tfunc_t func_;
};

log.hpp

此处我们在设置一个日志文件，完整的日志功能，至少: 日志等级 时间 支持用户自定义(日志内容, 文件行，文件名)；

#pragma once

#include <iostream>
#include <string>
#include <functional>

typedef std::function<int(int, int)> tfunc_t;

class Task
{
public:
    Task()
    {
    }

    Task(int x, int y, tfunc_t func) : x_(x), y_(y), func_(func)
    {
    }

    void operator()(const std::string& name)
    {
        // std::cout << "线程 " << name << " 处理完成, 结果是: " << x_ << "+" << y_ << "=" << func_(x_, y_) << std::endl;
        logMessage(WARNING, "%s处理完成:%d+%d = %d | %s | %d", name.c_str(), x_, y_, func_(x_, y_), __FILE__, __LINE__);
    }

private:
    int x_;
    int y_;
    tfunc_t func_;
};

运行代码后，我们就会发现此时就有4个线程，其中1个为主线程：
在这里插入图片描述
并且我们会发现这3个线程在处理时会呈现出一定的顺序性，因为主线程是每秒push一个任务，这3个线程只会有一个线程获取到该任务，其他线程都会在等待队列中进行等待，当该线程处理完任务后就会因为任务队列为空而排到等待队列的最后，当主线程再次push一个任务后会唤醒等待队列首部的一个线程，这个线程处理完任务后又会排到等待队列的最后，因此这3个线程在处理任务时会呈现出一定的顺序性。
在这里插入图片描述

单例模式下线程池实现

单例模式：指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

接下来我们以懒汉模式为例，来实现我们的线程池：

  1. 首先，我们需要将线程池中构造函数设置为私有，因为我们不想让他被多次访问，同时我们也要防止赋值和拷贝的情况发生，我们需要将拷贝构造函数与赋值运算符重载函数设置为私有或者删除；
  2. 提供一个指向单例对象的static指针，并在程序入口之前先将其初始化为空；
  3. 提供一个全局访问点获取单例对象。

通过上述三点就可以将我们的代码做出如下改变：

threadPool.hpp

#pragma once

#include <iostream>
#include <vector>
#include <queue>
#include <unistd.h>
#include "thread.hpp"
#include "lockGuard.hpp"
#include "log.hpp"

#define NUM 3

template <class T>
class ThreadPool
{
public:
    pthread_mutex_t *getMutex()
    {
        return &lock;
    }

    bool isEmpty()
    {
        return task_queue_.empty();
    }

    void waitCond()
    {
        pthread_cond_wait(&cond, &lock);
    }

    T getTask()
    {
        T t = task_queue_.front();
        task_queue_.pop();
        return t;
    }

private:
    ThreadPool(int thread_num = NUM) : num_(thread_num)
    {
        pthread_mutex_init(&lock, nullptr);
        pthread_cond_init(&cond, nullptr);

        for (int i = 1; i <= num_; i++)
        {
            threads_.push_back(new Thread(i, routine, this));
        }
    }

    ThreadPool(const ThreadPool<T> &other) = delete;
    const ThreadPool<T> &operator=(const ThreadPool<T> &other) = delete;

public:
    static ThreadPool<T> *getThreadPool(int num = NUM)
    {
        if (thread_ptr == nullptr)
        {
            LockGuard lockguard(&mutex);

            if (thread_ptr == nullptr)
            {
                thread_ptr = new ThreadPool<T>(num);
            }
        }

        return thread_ptr;
    }

    // 生产
    void run()
    {
        for (auto &iter : threads_)
        {
            iter->start();
            // std::cout << iter->name() << "启动成功" << std::endl;
            logMessage(NORMAL, "%s %s", iter->name().c_str(), "启动成功");
        }
    }

    static void *routine(void *args)
    {

        ThreadData *td = (ThreadData *)args;
        ThreadPool<T> *tp = (ThreadPool<T> *)td->args_;

        while (true)
        {
            T task;
            {
                LockGuard lockguard(tp->getMutex());

                while (tp->isEmpty())
                    tp->waitCond();

                task = tp->getTask();
            }

            // 处理任务
            task(td->name_);
        }
    }

    void pushTask(const T &task)
    {
        LockGuard lockguard(&lock);
        task_queue_.push(task);
        pthread_cond_signal(&cond);
    }

    ~ThreadPool()
    {
        for (auto &iter : threads_)
        {
            iter->join();
            delete iter;
        }

        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&cond);
    }

private:
    std::vector<Thread *> threads_; // 线程组
    int num_;
    std::queue<T> task_queue_; // 任务队列

    pthread_mutex_t lock; // 互斥锁
    pthread_cond_t cond;  // 条件变量

    static ThreadPool<T> *thread_ptr;
    static pthread_mutex_t mutex;
};

template <typename T>
ThreadPool<T> *ThreadPool<T>::thread_ptr = nullptr;

template <typename T>
pthread_mutex_t ThreadPool<T>::mutex = PTHREAD_MUTEX_INITIALIZER;

我们需要注意的是getThreadPool函数在创建对象过程中需要双检查加锁，因为简单的在if语句前后进行加锁解锁操作的话，后续在获取创建的单例对象操作时就会进行大量无意义的加锁解锁操作，我们进行双检查操作以后，就会加锁之前在进行一次判断，不为空就直接返回，就避免了后序无意义的加锁解锁操作；

testMain.cc

#include <iostream>
#include <ctime>
#include <unistd.h>
#include "threadPool.hpp"
#include "Task.hpp"
#include "log.hpp"

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid());
    // ThreadPool<Task>* tp = new ThreadPool<Task>();

    //启动线程
    ThreadPool<Task>::getThreadPool()->run();

    //主线程执行任务
    while(true)
    {
        int x = rand() % 100 + 1;
        usleep(1000);
        int y = rand() % 50 + 1;
        Task t(x, y, [](int x, int y)->int{
            return x + y;
        });

        logMessage(DEBUG, "制作任务完成：%d+%d=?", x, y);
        // std::cout << "制作任务完成: " << x << "+" << y << "=?" << std::endl;

        //将任务推送到线程池中
       ThreadPool<Task>::getThreadPool()->pushTask(t);

        sleep(1);
    }
    return 0;
}

STL、智能指针和线程安全

STL中的容器是否是线程安全的?

不是。原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响，而且对于不同的容器，加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶)，因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全。

智能指针是否是线程安全的?

  • 对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题；
  • 对于 shared_ptr, 多个对象需要共用一个引用计数变量, 所以会存在线程安全问题；但是标准库实现的时候考虑到了这个问题,，基于原子操作(CAS)的方式保证 shared_ptr 能够高效,，原子的操作引用计数。

其他常见的各种锁

  • 悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。
  • 乐观锁：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。
  • CAS操作：当需要更新数据时，判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不断重试。
  • 其次还有自旋锁，公平锁，非公平锁…

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

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

相关文章

QT5.15在Ubuntu22.04上编译流程

QT5.15在Ubuntu22.04上编译流程

在我们日常遇到的很多第三方软件中&#xff0c;有部分软件针对开发人员&#xff0c;并不提供预编译成果物&#xff0c;而是需要开发人员自行编译&#xff0c;此类问题有时候不是问题&#xff08;编译步骤的doc详细且清晰时&#xff09;&#xff0c;但有时候又很棘手&#xff08…
阅读更多...
【Proteus仿真】【Arduino单片机】直流电机和步进电机

【Proteus仿真】【Arduino单片机】直流电机和步进电机

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真Arduino单片机控制器&#xff0c;使用蜂鸣器、按键、直流电机、步进电机、ULN2003、L293D等。 主要功能&#xff1a; 系统运行后&#xff0c;K3键启动运行&#xff0c;K1和K2键控制…
阅读更多...
HashJoin 在 Apache Arrow 和PostgreSQL 中的实现

HashJoin 在 Apache Arrow 和PostgreSQL 中的实现

文章目录 背景PostgreSQL HashJoin实现PG 执行器架构HashJoin 基本流程HashJoin 实现细节Join 类型HashJoin 的划分阶段HashJoin 的分批处理阶段JOIN 类型的状态机转换HashJoin 的投影和过滤 Arrow Acero HashJoin实现Acero 基本框架HashJoin 基本流程 总结 背景 近两个月转到…
阅读更多...
YUV编码格式解析

YUV编码格式解析

YUV 颜色编码 YUV 颜色编码采用的是 明亮度 和 色度 来指定像素的颜色。 其中&#xff0c;Y 表示明亮度&#xff08;Luminance、Luma&#xff09;&#xff0c;而 U 和 V 表示色度&#xff08;Chrominance、Chroma&#xff09;。 而色度又定义了颜色的两个方面&#xff1a;色…
阅读更多...
知识管理的PSCA循环

知识管理的PSCA循环

前言&#xff1a;在PMP备考第二章《环境》部分&#xff0c;面对项目的复杂性&#xff0c;提到了知识管理的PSDA循环&#xff0c;本篇博客主要谈一下什么是PSDA循环&#xff0c;以及我们面对复杂的环境&#xff0c;如何提升自己的学习能力和认知水平。 目录 知识的冰山模型 P…
阅读更多...
搭建微信小程序环境及项目结构介绍

搭建微信小程序环境及项目结构介绍

一、注册 访问微信公众平台&#xff0c;将鼠标的光标置于账号分类中的小程序上&#xff0c; 点击‘查看详情’ 点击“前往注册” 下方也可以点击注册&#xff1a; 小程序注册页面&#xff1a; 步骤a:进入小程序注册页&#xff0c;根据指引填写信息和提交相应的资料&#x…
阅读更多...
OpenAI ： GPT-4 发布更新，整合了画图、插件、代码等能力

OpenAI ： GPT-4 发布更新，整合了画图、插件、代码等能力

本心、输入输出、结果 文章目录 OpenAI ： GPT-4 发布更新，整合了画图、插件、代码等能力前言GPT-4 的复合能力更新中的 automatic （自动的）获取天气我们看看讯飞星火的表现放大后内容并不是我们想要的我们看看百度文心一言的表现弘扬爱国精神OpenAI ： GPT-4 发布更新，整合…
阅读更多...
prometheus服务发现

prometheus服务发现

Consul简介 ◼ 一款基于golang开发的开源工具&#xff0c;主要面向分布式&#xff0c;服务化的系统提供服务注册、服务发现和配置管理 的功能 ◼ 提供服务注册/发现、健康检查、Key/Value存储、多数据中心和分布式一致性保证等功能 部署 curl -LO https://releases.hashicorp…
阅读更多...
SpringCloud Alibaba【三】Gateway

SpringCloud Alibaba【三】Gateway

Gateway配置与使用 前言新建gateway子项目pom.xml配置文件启动类访问接口方式 测试拓展 前言 在工作中遇到一种情况&#xff0c;一个父项目中有两个子项目。实际使用时&#xff0c;需要外网可以访问&#xff0c;宝信软件只能将一个端口号发布在外网上&#xff0c;所以需要运用…
阅读更多...
使用thinkphp6创建项目

使用thinkphp6创建项目

使用composer下载安装thinkphp6&#xff0c;命令&#xff1a;composer create-project topthink/think [文件名]如&#xff1a;composer create-project topthink/think thinkphp6&#xff0c;安装完成后如下图安装完成后进入创建的项目文件夹&#xff1a;cd thinkphp6执行命令…
阅读更多...
免费活动-11月4日敏捷武林上海站 | Scrum.org CEO 亲临现场

免费活动-11月4日敏捷武林上海站 | Scrum.org CEO 亲临现场

​​​​​​​ 活动介绍 过去的几年里&#xff0c;外界的风云变幻为我们的生活增添了一些不一样的色彩。在VUCA世界的浪潮里&#xff0c;每一个人都成为自己生活里的冒险家。面对每一次的变化&#xff0c;勇于探索未知&#xff0c;迎接挑战&#xff0c;努力追逐更好的自己。…
阅读更多...
宝塔面板安装Python和Flask（新版Python项目）

宝塔面板安装Python和Flask（新版Python项目）

&#xff08;一&#xff09;宝塔面板的项目菜单&#xff0c;打开Python项目的“项目版本管理” 安装Python版本3.10.0。 会创建一个Python版本的文件夹www/server/pyproject_evn/versions/ 会创建一个Python虚拟环境的文件夹www/server/pyproject_evn/python_venv/ &#xf…
阅读更多...
4、QtCharts 做心电图

4、QtCharts 做心电图

文章目录 ui界面核心代码全部代码 ui界面 核心代码 void Dialog::slot_timer() {qreal xOffset0.f;//x的偏移量,推进的距离qreal dIncrease10;//增加量//数据for(int i0;i<10;i){m_xdIncrease;xOffsetdIncrease;m_splineSerise->append(m_x,qrand()%10);//根据实际情况删…
阅读更多...
一、灵动mm32单片机_开发环境的搭建(Keil)

一、灵动mm32单片机_开发环境的搭建(Keil)

1、安装Keil MDK。 略。 2、安装芯片对应的Pack包。 (1)这里以MM32F0130单片机为例。 (2)进入灵动微电子官网。上海灵动微电子股份有限公司 (3)点击“支持”→“KEILPacl”。 (3)点击下载Pack包。 (4)下载后&#xff0c;解压下载的压缩包&#xff0c;找到对应的Pack包&…
阅读更多...
Golang关键字-select

Golang关键字-select

一、Select解决什么问题&#xff1f; 在Golang中&#xff0c;两个协程之间通信Channel&#xff08;图一&#xff09;&#xff0c;在接受协程中通过代码表示即为<ch&#xff1b;如果协程需要监听多个Channel&#xff0c;只要有其中一个满足条件&#xff0c;就执行相应的逻辑&…
阅读更多...
DIANA算法c++实现

DIANA算法c++实现

第一步对具有最大直径的簇中每个点计算平均相异度找出最大的点放入splinter group&#xff0c;其余放在放入splinter group 第二步 在old party里找出到splinter group中点的最近距离 < 到old party中点的最近距离的点&#xff0c;并将该点加入splinter group 重复第二步的…
阅读更多...
使用DBSyncer实现增量Mysql到Mysql的数据同步_DBSyncer1.2.4版本---数据同步之DBSyncer工作笔记006

使用DBSyncer实现增量Mysql到Mysql的数据同步_DBSyncer1.2.4版本---数据同步之DBSyncer工作笔记006

之前都是用来postgresql到mysql的同步,需要配置postgresql的复制槽,对于mysq来说,需要配置: mysql启用binlog: https://gitee.com/ghi/dbsyncer/wikis/%E6%93%8D%E4%BD%9C%E6%89%8B%E5%86%8C/%E6%97%A5%E5%BF%97%E9%85%8D%E7%BD%AE%EF%BC%88%E6%95%B0%E6%8D%AE%E6%BA%90%EF%B…
阅读更多...
软件测试---等价类划分（功能测试）

软件测试---等价类划分（功能测试）

能对穷举场景设计测试点-----等价类划分 等价类划分 说明&#xff1a;在所有测试数据中&#xff0c;具有某种共同特征的数据集合进行划分分类&#xff1a; 1&#xff09;有效等价类 2&#xff09;无效等价类步骤&#xff1a;1&#xff09;明确需求 2&#xff09;确定有效和无…
阅读更多...
景联文科技提供4D-BEV标注工具：提升自动驾驶感知能力的精准数据支持

景联文科技提供4D-BEV标注工具：提升自动驾驶感知能力的精准数据支持

4D-BEV标注是一种用于自动驾驶领域的数据标注方法。在3D空间的基础上&#xff0c;加入了时间维度&#xff0c;形成了四个维度。这种方法通过精准地跟踪和记录动态对象&#xff08;如车辆、行人&#xff09;的运动轨迹、姿势变化以及速度等信息&#xff0c;全面理解和分析动态对…
阅读更多...
05、Python -- 爬取ts文件格式视频思路

05、Python -- 爬取ts文件格式视频思路

目录 第一步&#xff1a;爬取一段5秒视频找url代码结果 第二步&#xff1a;下载整个视频的所有片段代码&#xff1a;结果&#xff1a; 第三步&#xff1a;合成视频安装模块代码&#xff1a;结果 简洁代码代码&#xff1a;结果&#xff1a; 最终代码简洁前代码简洁后代码 思路&a…
阅读更多...
最新文章

Copyright @ 2022~2023