线程池C和C++实现

news2024/11/24 17:20:27

一、线程池介绍

1）应用场景

当并发数很多的时候，并且每个线程执行时间很短的任务，这样就会频繁创建线程，而这样的频繁创建和销毁线程会大大降低系统的执行效率。对于这种场景我们可以使用线程池来复用之前创建的线程，降低线程的频繁创建和销毁工作，达到提高执行效率的目的。

2）线程池原理

线程池使用者往线程池任务队列里面添加任务，线程池会根据任务的多少来自动创建或销毁工作线程取执行任务，即当任务数量比较多而线程池比较少处于忙不过来的状态时，线程池就会自动创建线程，而当仍务数量比较少而空闲线程比较多时，线程池就会自动销毁一部分空闲线程。其中任务队列、线程池使用者和工作线程组成一个生产者消费者模型，线程池使用者（消费者）检查队列已满就阻塞，否则就向任务队列添加任务并通知工作线程（消费者）取任务执行，而工作线程（消费者）取任务之后也会向线程池使用者（生产者）发送通知解阻塞。

3）线程池结构

线程池由任务队列、工作线程和管理线程三部分组成，他们的所用分别如下。

  • 任务队列：
    • 负责保存要执行的任务（一般每个任务就是一个回调函数）；
    • 线程池使用者（生产者）往任务队列里面添加任务，并通知工作线程（消费者）取任务执行；
    • 工作线程（消费者）从任务队列里面获取到任务后，需要把该任务从队列中删除；
  • 工作线程：
    • 负责执行任务队列里面的任务；
    • 当任务队列没有任务时，工作线程便自动睡眠防止占用CPU资源；
    • 当由任务时唤醒工作线程，从队列中取任务执行（从队列中取出任务后，如果生产者此时阻塞的话可以通知生产者解阻塞）；
  • 管理线程：
    • 负责控制工作线程的数量；
    • 当空闲的工作线程数量比较多时，就销毁一部分线程；
    • 当队列任务比较多而工作线程比较少时，新创建一部分线程；

线程池结构图

二、程序实现

1）C语言实现

threadPool.h

#ifndef _THREAD_POOL_
#define _THREAD_POOL_

typedef struct ThreadPool ThreadPool;

// 创建并初始化线程池
ThreadPool* threadPoolCreate(int queueSize, int minNum, int maxNum);

// 销毁线程池
void threadPoolDestory(ThreadPool* pool);

// 往线程池添加任务
int threadPoolAdd(ThreadPool* pool, void (*handler)(void* arg), void* arg);

// 获取线程池当前工作线程数
int threadPoolWorkNum(ThreadPool* pool);

// 获取线程池当前存活线程数
int threadPoolLiveNum(ThreadPool* pool);

#endif // _THREAD_POOL_

threadPool.c

#include "threadPool.h"
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <error.h>
#include <string.h>
#include <unistd.h>

#define CHAGNUM 4

void* worker(void *arg);
void* manager(void *arg);
void threadExit(ThreadPool* pool);

typedef struct Task {
    void (*handler)(void* arg);
    void* arg;
}Task;

struct ThreadPool {
    Task* taskQ;
    int qCapacity;
    int qSize;
    int qFront;
    int qBack;

    pthread_t manageID;
    pthread_t* workIDs;
    int maxNum;
    int minNum;
    int workNum;
    int liveNum;
    int exitNum;

    pthread_mutex_t mutexPool;
    pthread_mutex_t mutexWork; // 锁workNum变量
    pthread_cond_t hasTask;      // 任务队列是否有任务
    pthread_cond_t isFull;       // 任务队列是否已满

    int isDestory; // 线程池是否销毁
};

ThreadPool* threadPoolCreate(int queueSize, int minNum, int maxNum)
{
    int i, res = 0;

    // 创建线程池对象
    ThreadPool* tPool = (ThreadPool*)malloc(sizeof(struct ThreadPool));
    if (tPool == NULL) {
        perror("tPool malloc:");
        goto err;
    }

    // 创建任务队列
    tPool->taskQ = (Task*)malloc(sizeof(struct Task) * queueSize);
    if (tPool->taskQ == NULL) {
        perror("taskQ malloc:");
        goto err;
    }
    tPool->qSize = 0;
    tPool->qCapacity = queueSize;
    tPool->qFront = tPool->qBack = 0;

    // 创建存储工作线程ID的数组
    tPool->workIDs = (pthread_t*)malloc(sizeof(pthread_t) * maxNum);
    if (tPool->workIDs == NULL) {
        perror("workIDs malloc:");
        goto err;
    }
    memset(tPool->workIDs, 0, sizeof(pthread_t) * maxNum);
    tPool->maxNum = maxNum;
    tPool->minNum = minNum;
    tPool->workNum = 0;
    tPool->liveNum = minNum;
    tPool->exitNum = 0;

    tPool->isDestory = 0;
    // 初始化互斥量和条件变量
    if (pthread_mutex_init(&tPool->mutexPool, NULL) != 0 ||
        pthread_mutex_init(&tPool->mutexWork, NULL) != 0 ||
        pthread_cond_init(&tPool->isFull, NULL) != 0 ||
        pthread_cond_init(&tPool->hasTask, NULL) != 0) {
        printf("mutex or cond init fail...\n");
        goto err;
    }
    

    // 创建工作线程
    for (i = 0; i < minNum; i++) {
        res = pthread_create(&tPool->workIDs[i], NULL, worker, tPool);
        if (res != 0) {  // todo: 这里失败返回之前创建的线程可能会泄露
            printf("thread create failed for worker, errno: %d, idx: %d\n", res, i);
            goto err;
        }
    }

    // 创建管理线程
    res = pthread_create(&tPool->manageID, NULL, manager, tPool);
    if (res != 0) {
        printf("thread create failed for manager, errno: %d\n", res);
        goto err;
    }

    return tPool;

err:
    if (tPool && tPool->taskQ) {
        free(tPool->taskQ);
        tPool->taskQ = NULL;
    }

    if (tPool && tPool->workIDs) {
        free(tPool->workIDs);
        tPool->workIDs = NULL;
    }

    if (tPool) {
        free(tPool);
    }
    return NULL;
}

void* worker(void *arg)
{
    Task task;
    ThreadPool* pool = (ThreadPool*)arg;

    while(1) {
        pthread_mutex_lock(&pool->mutexPool);

        // 队列为空就阻塞当前线程，避免占用CPU
        while(pool->qSize == 0 && !pool->isDestory) {
            pthread_cond_wait(&pool->hasTask, &pool->mutexPool);
            
            // 减少空闲线程
            if (pool->exitNum > 0) {
                pool->exitNum--;
                if (pool->liveNum > pool->minNum) {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    threadExit(pool);
                }
            }
        }

        // 销毁线程池
        if (pool->isDestory) {
            pool->liveNum--;
            pthread_mutex_unlock(&pool->mutexPool);
            threadExit(pool);
        }

        // 取一个任务执行
        task.arg = pool->taskQ[pool->qFront].arg;
        task.handler = pool->taskQ[pool->qFront].handler;
        pool->qFront = (pool->qFront + 1) % pool->qCapacity;
        pool->qSize--;
        pthread_cond_signal(&pool->isFull);
        pthread_mutex_unlock(&pool->mutexPool);

        pthread_mutex_lock(&pool->mutexWork);
        pool->workNum++;
        pthread_mutex_unlock(&pool->mutexWork);
        task.handler(task.arg);
        if (task.arg) {  // 释放资源 或者 用户在回调函数中释放这里就不释放了
            free(task.arg);
            task.arg = NULL;
        }

        pthread_mutex_lock(&pool->mutexWork);
        pool->workNum--;
        pthread_mutex_unlock(&pool->mutexWork);
    }

    return NULL;
}

void* manager(void *arg)
{
    int i = 0, incNum = CHAGNUM;
    ThreadPool* pool = (ThreadPool*)arg;

    while(!pool->isDestory) {
        sleep(3);
        pthread_mutex_lock(&pool->mutexPool);
        int queueSize = pool->qSize;
        int liveNum = pool->liveNum;
        pthread_mutex_unlock(&pool->mutexPool);

        pthread_mutex_lock(&pool->mutexWork);
        int workNum = pool->workNum;
        pthread_mutex_unlock(&pool->mutexWork);

        // 数据处理不过来要增加线程
        if (queueSize > liveNum) {
            pthread_mutex_lock(&pool->mutexPool);
            for(i = 0; i < pool->maxNum && incNum > 0; i++) {
                if (pool->workIDs[i] == 0) {
                    pthread_create(&pool->workIDs[i], NULL, worker, pool);
                    incNum--;
                    pool->liveNum++;
                    printf("new thread %ld, liveNum = %d, workNum = %d\n",
                        pool->workIDs[i], pool->liveNum, pool->workNum);
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }
        
        // 空闲线程多了要销毁
        if(workNum * 2 < liveNum &&
            liveNum - CHAGNUM > pool->minNum) {

            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNum = CHAGNUM;
            pthread_mutex_unlock(&pool->mutexPool);

            for (i = 0; i < CHAGNUM; i++) {
                pthread_cond_signal(&pool->hasTask);
            }
        }
    }
    return NULL;
}

int threadPoolAdd(ThreadPool* pool, void (*handler)(void* arg), void* arg)
{
    pthread_mutex_lock(&pool->mutexPool);
    while(pool->qSize == pool->qCapacity && !pool->isDestory)  {
        pthread_cond_wait(&pool->isFull, &pool->mutexPool);
    }
    if (pool->isDestory) {
        pthread_mutex_unlock(&pool->mutexPool);
        return -1;
    }

    pool->taskQ[pool->qBack].arg = arg;
    pool->taskQ[pool->qBack].handler = handler;
    pool->qBack = (pool->qBack + 1) % pool->qCapacity;
    pool->qSize++;
    pthread_cond_signal(&pool->hasTask); // 通知空闲的工作线程取任务执行
    pthread_mutex_unlock(&pool->mutexPool);
    return 0;
}

void threadExit(ThreadPool* pool)
{
    int i;
    pthread_t tid = pthread_self();
    for(i = 0; i < pool->maxNum; i++) {
        if (pool->workIDs[i] == tid) {
            pool->workIDs[i] = 0;
            break;
        }
    }
    printf("thread %ld exit, liveNum = %d, workNum = %d\n",
        tid, pool->liveNum, pool->workNum);
    pthread_exit(0);
}

int threadPoolWorkNum(ThreadPool* pool)
{
    int workNum;

    pthread_mutex_lock(&pool->mutexWork);
    workNum = pool->workNum;
    pthread_mutex_unlock(&pool->mutexWork);

    return workNum;
}

int threadPoolLiveNum(ThreadPool* pool)
{
    int liveNum;

    pthread_mutex_lock(&pool->mutexPool);
    liveNum = pool->liveNum;
    pthread_mutex_unlock(&pool->mutexPool);

    return liveNum;
}

void threadPoolDestory(ThreadPool* pool)
{
    int i;

    if (pool == NULL) {
        return;
    }
    pool->isDestory = 1;
    // 销毁管理线程
    pthread_join(pool->manageID, NULL);

    // 销毁工作线程
    for (i = 0; i < pool->maxNum; i++) {
        if (pool->workIDs[i] > 0) {
            pthread_cond_signal(&pool->hasTask);
        }
    }
    for (i = 0; i < pool->maxNum; i++) {
        if (pool->workIDs[i] > 0) {
            pthread_join(pool->workIDs[i], NULL);
        }
    }

    pthread_mutex_destroy(&pool->mutexPool);
    pthread_mutex_destroy(&pool->mutexWork);
    pthread_cond_destroy(&pool->hasTask);

    if (pool->workIDs) {
        free(pool->workIDs);
        pool->workIDs = NULL;
    }
    if (pool->taskQ) {
        free(pool->taskQ);
        pool->taskQ = NULL;
    }
    free(pool);
    printf("thread pool destory...\n");
}

main.c

#include "threadPool.h"
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

void myTest(void *arg)
{
    printf("tid: %ld, num = %d\n", pthread_self(), *(int *)arg);
    sleep(3);
}

int main()
{
    int i;
    ThreadPool *pool = threadPoolCreate(20, 4, 10);
    for (i = 0; i < 40; i++) {
        int* num = (int *)malloc(sizeof(int));
        *num = i;
        threadPoolAdd(pool, myTest, num);
    }
    sleep(10);
    threadPoolDestory(pool);
    return 0;
}

2）C++实现

threadPool.h

#ifndef _THREADPOOL_H
#define _THREADPOOL_H
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <queue>

struct Task  {
    void (*handler)(void*);
    void* arg = nullptr;
};

class TaskQueue {
public:
    TaskQueue();
    ~TaskQueue();

    // 添加任务
    void addTask(Task& task);
    void addTask(void (*handler)(void*), void* arg);

    // 取出任务
    Task getTask();

    // 获取任务数
    inline int getTaskNum();

private:
    pthread_mutex_t m_lock;
    std::queue<Task> m_que;
};

class ThreadPool {
public:
    ThreadPool(int max, int min);
    ~ThreadPool();

    // 添加任务
    void addTask(Task task);

    // 获取工作线程数
    int getWorkNum();

    // 获取存活线程数
    int getLiveNum();

private:
    static void* worker(void* arg);
    static void* manager(void* arg);

    void threadExit();

private:
    TaskQueue m_taskQ;
    int m_maxNum;
    int m_minNum;
    int m_workNum;
    int m_liveNum;
    int m_exitNum;
    static const int m_changeNum = 2;

    bool m_isDestory = false;

    pthread_t m_managerTid;
    pthread_t* m_workTids;

    pthread_cond_t m_hasTask;
    pthread_mutex_t m_lock; // 锁m_workNUm、m_liveNum、m_exitNum变量
};

#endif // _THREADPOOL_H

threadPool.cpp

#include "threadPool.h"
#include <iostream>

ThreadPool::ThreadPool(int max, int min)
{
    int i;
    m_maxNum = max;
    m_minNum = min;
    m_workNum = 0;
    m_liveNum = min;
    m_exitNum = 0;

    if (pthread_cond_init(&m_hasTask, nullptr) != 0
        || pthread_mutex_init(&m_lock, nullptr) != 0) {
            std::cout << "cond or mutex init fail..." << std::endl;
            return;
    }

    m_workTids = new pthread_t[m_maxNum];
    if(m_workTids == nullptr) {
        std::cout << "m_workTids malloc failed..." << std::endl;
    }
    memset(m_workTids, 0, sizeof(pthread_t) * m_maxNum);
    
    // 创建工作线程
    for (i = 0; i < m_minNum; i++) {
        pthread_create(&m_workTids[i], nullptr, worker, this); // todo: 为什么这里worker改成静态函数就没问题了？
        std::cout << "worker thread " << m_workTids[i] << " created" << std::endl;
    }

    // 创建管理线程
    pthread_create(&m_managerTid, nullptr, manager, this);
}

ThreadPool::~ThreadPool()
{
    m_isDestory = true;

    pthread_join(m_managerTid, nullptr);

    pthread_cond_broadcast(&m_hasTask);

    for (int i = 0; i < m_maxNum; i++) {
        if (m_workTids[i] != 0) {
            pthread_join(m_workTids[i], nullptr);
            std::cout << "thread i = " << i << " tid = " << m_workTids[i] << " exit..." << std::endl;
            m_workTids[i] = 0;
        }
    }

    pthread_mutex_destroy(&m_lock);
    pthread_cond_destroy(&m_hasTask);

    if (m_workTids) {
        delete []m_workTids;
    }
    std::cout << "liveNum = "<< m_liveNum <<", workNum = "<< m_workNum <<", queSize = " << this->m_taskQ.getTaskNum() << std::endl;
}

void* ThreadPool::worker(void* arg)
{
    ThreadPool* pool = static_cast<ThreadPool*>(arg);

    while(1) {
        pthread_mutex_lock(&pool->m_lock);
        while(pool->m_taskQ.getTaskNum() == 0 && !pool->m_isDestory) {
            std::cout << "thread " << pthread_self() << " waitting..." << std::endl;
            pthread_cond_wait(&pool->m_hasTask, &pool->m_lock);
            // 空闲线程退出
            if (pool->m_exitNum > 0) {
                pool->m_exitNum--;
                if(pool->m_liveNum > pool->m_minNum) { // todo：为什么这里面不能直接访问成员变量，还有私有成员为什么可以用->访问？
                    pool->m_liveNum--;
                    pthread_mutex_unlock(&pool->m_lock);
                    pool->threadExit();
                }
            }
        }

        // 销毁线程池
        if (pool->m_isDestory) {
            pool->m_liveNum--;
            pthread_mutex_unlock(&pool->m_lock);
            pthread_exit(0);  // 这里不调用threadExit是让主线程好回收资源
        }
        // 取任务执行
        Task task = pool->m_taskQ.getTask();
        pool->m_workNum++;
        pthread_mutex_unlock(&pool->m_lock);
        task.handler(task.arg);  // 用户自己取释放arg内存
        pthread_mutex_lock(&pool->m_lock);
        pool->m_workNum--;
        pthread_mutex_unlock(&pool->m_lock);

    }
    return nullptr;
}

void* ThreadPool::manager(void* arg)
{
    ThreadPool* pool = static_cast<ThreadPool*>(arg);

    while(!pool->m_isDestory) {
        sleep(3);

        int liveNum;
        int taskNum;
        int workNum;
        int i, incNum = pool->m_changeNum;

        pthread_mutex_lock(&pool->m_lock);
        liveNum = pool->m_liveNum;
        workNum = pool->m_workNum;
        taskNum = pool->m_taskQ.getTaskNum();
        pthread_mutex_unlock(&pool->m_lock);

        // 任务太多忙不过来需要创建线程
        if(!pool->m_isDestory && taskNum > liveNum && liveNum < pool->m_maxNum) {
            for (i = 0; i < pool->m_maxNum && incNum > 0 ; i++) {
                pthread_mutex_lock(&pool->m_lock);
                if (pool->m_workTids[i] == 0) {
                    pool->m_liveNum++;
                    incNum--;
                    pthread_create(&pool->m_workTids[i], NULL, worker, pool);
                    std::cout << "new thread " << pool->m_workTids[i] << " created" << std::endl;
                }
                pthread_mutex_unlock(&pool->m_lock);
            }
        }

        // 销毁多余的空闲线程
        incNum = pool->m_changeNum;
        if (!pool->m_isDestory && workNum * 2 < liveNum && liveNum > pool->m_minNum) {
            pthread_mutex_lock(&pool->m_lock);
            pool->m_exitNum = pool->m_changeNum;
            pthread_mutex_unlock(&pool->m_lock);
            while (incNum--) {
                pthread_cond_signal(&pool->m_hasTask);
            }
        }
    }
    return nullptr;
}

void ThreadPool::addTask(Task task)
{
    if (m_isDestory) {
        return;
    }
    pthread_mutex_lock(&m_lock);
    m_taskQ.addTask(task);
    pthread_mutex_unlock(&m_lock);
    pthread_cond_signal(&m_hasTask);
}

void ThreadPool::threadExit()
{
    for (int i = 0; i < m_maxNum; i++) {
        if (m_workTids[i] == pthread_self()) {
            std::cout << "thread " << m_workTids[i] << " exit..." << std::endl;
            pthread_mutex_lock(&m_lock);
            m_workTids[i] = 0;
            pthread_mutex_unlock(&m_lock);
            pthread_exit(0);
        }
    }
}

int ThreadPool::getWorkNum()
{
    int workNum = 0;
    pthread_mutex_lock(&m_lock);
    workNum = m_workNum;
    pthread_mutex_unlock(&m_lock);
    return m_workNum;
}

int ThreadPool::getLiveNum()
{
    int liveNum = 0;
    pthread_mutex_lock(&m_lock);
    liveNum = m_liveNum;
    pthread_mutex_unlock(&m_lock);
    return liveNum;
}

TaskQueue::TaskQueue() 
{
    pthread_mutex_init(&m_lock, NULL);
}

TaskQueue::~TaskQueue() 
{
    pthread_mutex_destroy(&m_lock);
}

void TaskQueue::addTask(Task& task)
{
    pthread_mutex_lock(&this->m_lock);
    m_que.push(task);
    pthread_mutex_unlock(&this->m_lock);
}

void TaskQueue::addTask(void (*handler)(void*), void* arg)
{
    Task task;
    task.arg = arg;
    task.handler = handler; 
    pthread_mutex_lock(&this->m_lock);
    m_que.push(task);
    pthread_mutex_unlock(&this->m_lock);
}

Task TaskQueue::getTask()
{
    Task task;

    pthread_mutex_lock(&this->m_lock);
    if (m_que.size() > 0) {
        task = m_que.front();
        m_que.pop();
    }
    pthread_mutex_unlock(&this->m_lock);

    return task;
}

inline int TaskQueue::getTaskNum()
{
    return this->m_que.size();
}

main.cpp

#include "threadPool.h"
#include <iostream>
using namespace std;
 
void my_test(void* arg)
{
    int num = *(int*)arg;
    cout << "thread id: " << pthread_self() << " , num: " << num << endl;
    sleep(1);
    delete (int*)arg;
}

int main()
{
    ThreadPool* pool = new ThreadPool(10, 4);
    sleep(1);
    for (int i = 0; i < 30; i++) {
        Task task;
        task.handler = my_test;
        task.arg = new int(i);
        pool->addTask(task);
    }
    sleep(10);
    delete pool;
    return 0;
}

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

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

相关文章

Java 与排序算法（7）：堆排序

Java 与排序算法（7）：堆排序

一、堆排序 堆排序是一种基于比较的排序算法&#xff0c;它的基本思想是将待排序的元素构建成一个堆&#xff0c;然后依次将堆顶元素取出&#xff0c;放到已排序的序列中&#xff0c;直到堆中所有元素都被取出&#xff0c;最终得到一个有序的序列。 堆是一种特殊的树形数据结…
阅读更多...
5.24 基础题目

5.24 基础题目

快速幂 #include<bits/stdc.h> using namespace std; //126348976 982638476 938420413 int main(){int a,b,p;cin>>a>>b>>p;long long res 1,ci1;int flag0;if(b0){res%p;}else{while(b){if (flag0)cia%p;elseci(ci%p)*(ci%p)%p;if (b&1)res(res…
阅读更多...
【学习随笔】

【学习随笔】

2022/11/13 HTML :讲完了 css&#xff1a;讲完了 作业&#xff1a;编写登陆界面、整理一下sql优化,对于mybatis不熟练的继续练习 关于MySQL优化的问题? 思路总结&#xff1a;主要考虑数据库优化与SQL语句优化。 1&#xff0c;数据库优化&#xff0c;包括存储引擎的优化&…
阅读更多...
FreeRTOS：时间管理

FreeRTOS：时间管理

目录 前言一、FreeRTOS 延时函数1.1函数vTaskDelay()1.2 函数prvAddCurrentTaskToDelayedList()1.3 函数vTaskDelayUntil() 二、FreeRTOS 系统时钟节拍 前言 在使用FreeRTOS 的过程中我们通常会在一个任务函数中使用延时函数对这个任务延时&#xff0c;当执行延时函数的时候就…
阅读更多...
【C/C++】内存管理

【C/C++】内存管理

【C/C】内存管理 目录 【C/C】内存管理C/C内存分布C语言和C中动态内存管理方式new/delete操作内置类型new和delete操作自定义类型 operator new与operator delete函数operator new与operator delete的类专属重载new和delete的实现原理定位new表达式(placement-new)重要的知识ma…
阅读更多...
Docker(1)

Docker(1)

一)什么是虚拟化&#xff1f;容器化&#xff1f; 1)物理机:实际的服务器或者计算机&#xff0c;相对于虚拟机而言的对实体计算机的称呼。物理 机提供给虚拟机以硬件环境&#xff0c;有时也称为“寄主”或“宿主&#xff1b; 2)虚拟化:是指通过虚拟化技术将一台计算机虚拟为多台…
阅读更多...
【C++】——string类的介绍及模拟实现

【C++】——string类的介绍及模拟实现

文章目录 1. 前言2. string类的常用接口2.1 string类对象的常见构造2.2 string类对象的容量操作2.3 string类对象的访问及遍历操作2.4 string类对象的修改操作2.5 string类非成员函数2.6 string四种迭代器类型2.7 string类的insert和erase函数 3. 浅拷贝和深拷贝4. string类模拟…
阅读更多...
评奖系统设计

评奖系统设计

系列文章 任务40 评奖系统设计 文章目录 系列文章一、实践目的与要求1、目的2、要求 二、课题任务三、总体设计1.存储结构及数据类型定义2.程序结构3.所实现的功能函数4、程序流程图 四、小组成员及分工五、 测试执行完毕程序展示成功&#xff01;学生投票&#xff0c;举例第一…
阅读更多...
URP的多Pass和Features用法

URP的多Pass和Features用法

回到目录 大家好&#xff0c;我是阿赵。这里用一个传统的描边例子来说明一下&#xff0c;URP下怎么使用多Pass和Features。 一、传统多Pass描边 最常用的制作描边方法&#xff0c;就是写多一个Cull Front的Pass&#xff0c;然后通过法线方向扩展顶点&#xff0c;模拟描边的效…
阅读更多...
机试打卡 -05 接雨水（动态规划栈）

机试打卡 -05 接雨水（动态规划栈）

我的思路&#xff1a;依次计算每一列能接收的雨水量。 关键点&#xff1a;如何计算得到每一列所能接收到的雨水量&#xff1f; 某一列能够接收到的雨水量&#xff0c;取决于其左右两侧最高的柱子。仅有当左右两侧的柱子均高于该列的高度&#xff0c;该列才可收到雨水&#x…
阅读更多...
Java 17 VS Java 8: 新旧对决，这些Java 17新特性你不容错过

Java 17 VS Java 8: 新旧对决，这些Java 17新特性你不容错过

&#x1f3c5; 欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 如有错误敬请指正&#xff01; Java是一门非常流行的编程语言&#xff0c;由于其跨平台性、可移植性以及强大的面向对象特性而备受青睐。Java最初由Sun Microsystems公司于1995年推出&#xff0c;随着时间的推…
阅读更多...
[极客大挑战 2019]HardSQL1

[极客大挑战 2019]HardSQL1

拿到题目是一个登录界面 提交万能密码后拿到回显信息&#xff0c;说明页面存在过滤 burp抓包爆破后发现&#xff0c;所有736都是被过滤字符 联合注入和时间盲注被过滤&#xff0c;因为页面存在报错信息&#xff0c;所以尝试报错注入 因为空格也被过滤&#xff0c;所以我们使用括…
阅读更多...
HOMER docker版本配置优化

HOMER docker版本配置优化

概述 HOMER是一款100%开源的针对SIP/VOIP/RTC的抓包工具和监控工具。 HOMER是一款强大的、运营商级、可扩展的数据包和事件捕获系统&#xff0c;是基于HEP/EEP协议的VoIP/RTC监控应用程序&#xff0c;并可以使用即时搜索、处理和存储大量的信令、RTC事件、日志和统计信息。 …
阅读更多...
机器学习-01概论

机器学习-01概论

人们在生活中可能已经注意到了这样一种现象&#xff1a;我们能够轻松地通过相貌区分出日本人、韩国人和泰国人&#xff0c;但是面对英国人、俄罗斯人和德国人时&#xff0c;我们却很难辨认他们的面孔。造成这种现象的原因一方面是因为日韩泰都是我国的邻国&#xff0c;我们观察…
阅读更多...
信号处理与分析-确定性信号的分析

信号处理与分析-确定性信号的分析

目录 一、引言 二、确定性信号的定义 三、确定性信号的分类 四、确定性信号的分析方法 4.1 傅里叶变换 4.2 离散傅里叶变换 4.3 离散余弦变换 4.4 小波变换 五、确定性信号的处理方法 六、结论 一、引言 信号分析与处理是现代通信技术和信息处理技术的重要组成部分。…
阅读更多...
Redis安装及其配置文件修改

Redis安装及其配置文件修改

一、redis 安装 点击即可下载 https://download.redis.io/releases/ 将下载后的包通过xftp上传到服务器 解压&#xff0c;我这边是解压到/usr/local目录下 -- 创建路径 mkdir /usr/local/redis -- 解压 tar -zxvf redis-4.0.0.tar.gz -C /usr/local/redis 为防止编译失败&am…
阅读更多...
MyBatis-Plus精讲和使用注意事项

MyBatis-Plus精讲和使用注意事项

&#x1f353; 简介&#xff1a;java系列技术分享(&#x1f449;持续更新中…&#x1f525;) &#x1f353; 初衷:一起学习、一起进步、坚持不懈 &#x1f353; 如果文章内容有误与您的想法不一致,欢迎大家在评论区指正&#x1f64f; &#x1f353; 希望这篇文章对你有所帮助,欢…
阅读更多...
【国产虚拟仪器】基于Zynq的雷达10Gbps高速PCIE数据采集卡方案(一）总体设计

【国产虚拟仪器】基于Zynq的雷达10Gbps高速PCIE数据采集卡方案(一）总体设计

2.1 引言 本课题是来源于雷达辐射源识别项目&#xff0c;需要对雷达辐射源中频信号进行采集传输 和存储。本章基于项目需求&#xff0c;介绍采集卡的总体设计方案。采集卡设计包括硬件设计 和软件设计。首先对采集卡的性能和指标进行分析&#xff0c;接着提出硬件的总体设计…
阅读更多...
详解知识蒸馏原理和代码

详解知识蒸馏原理和代码

目录 知识蒸馏原理概念技巧举例说明KL 散度及损失 KD训练代码导入包网络架构teacher网络student网络 teacher网络训练定义基本函数训练主函数 student网络训练&#xff08;重点&#xff09;理论部分定义kd的loss定义基本函数训练主函数 绘制结果teacher网络的暗知识softmax_t推…
阅读更多...
使用dockerfile自定义Tomcat镜像

使用dockerfile自定义Tomcat镜像

一&#xff1a;创建目录 mkdir /root/tomcat chmod 777 /root/ chmod 777 /root/tomcat 或者chmod -R 777 /root 这里的无效选项是因为我想递归修改root目录及root目录文件以下的权限 chmod :-R 递归修改指定目录下所有子目录和文件的权限 二&#xff1a;将jdk和apache压…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023