池式结构-线程池

最新推荐文章于 2023-08-28 01:15:52 发布
最新推荐文章于 2023-08-28 01:15:52 发布
阅读量233 收藏
点赞数 1
分类专栏： 池式结构 C/C++
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/u014183456/article/details/118468040
版权

线程池 多线程 任务队列 回调函数 线程管理
关键词由CSDN通过智能技术生成

文章目录


在多线程的操作中，我们经常使用线程池来进行大量的计算、缓存磁盘、写log等。线程池主要由 任务队列、 执行队列和 管理组件。三部分组成。如图，中间的框框就是我们的线程池，threadqueue负责从taskqueue取任务，当没有任务时，thread通过条件变量进行等待。处理完成之后，返回处理的结果。
在这里插入图片描述

任务队列

typedef struct job {
    void (*func)(struct job *arg); 
    void *userdata;

    struct job *prev;
    struct job *next;
}job_t;

任务队列主要主要有回调处理函数，和用户数据、前指针和后指针组成。

执行队列

typedef struct work {
    pthread_t thread;
    int treminate;
    struct workqueue *threadpool;

    struct work *prev;
    struct work *next;
}work_t;

执行队列就是我们的threadqueue。 主要有线程id, terminate标志可以使线程退出，线程池的指针、前指针和后指针组成。

管理组件

typedef struct workqueue{
    struct work *works;
    struct job  *jobs;

    pthread_cond_t jobs_cond;
    pthread_mutex_t jobs_mutex;
}threadpool;

管理组件就是我们的线程池了，也就是对任务队列和执行队列进行加锁，通知等。

基本组件了解之后，我们就要对线程池进行创建、任务分配、销毁等。

创建线程池

int ThreadPoolCreate(threadpool *pool, int numWorks) {
    if(numWorks < 1) numWorks = 1;
    memset(pool, 0, sizeof(threadpool));

    pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;
    pthread_mutex_t bland_mutex = PTHREAD_MUTEX_INITIALIZER;

    memcpy(&pool->jobs_cond, &blank_cond, sizeof(pool->jobs_cond));
    memcpy(&pool->jobs_mutex, &bland_mutex, sizeof(pool->jobs_mutex));

    for (int i = 0; i < numWorks; ++i) {
        work_t *worker =  (work_t *)calloc(1, sizeof(work_t));
        if(worker == NULL) {
            perror("calloc");
            return -1;
        }
        worker->threadpool = pool;

        int ret = pthread_create(&worker->thread, NULL, ThreadFunc, (void *)worker);
        
        if(ret) {
            perror("pthread_create");
            free(worker);
            return -1;
        }

        LL_ADD(worker, worker->threadpool->works);
    }

    return 0;
}

线程池的创建也很简单，主要对条件变量和互斥锁进行初始化。对每个任务进行创建线程，并加入到threadqueue中。创建完线程之后，线程就开始运行了。

线程运行

static void *ThreadFunc(void *arg) {
    work_t *worker = (work_t*)arg;
    printf("pid :%u, tid: %ld, self: %lu\n", getpid(), (long int)syscall(__NR_gettid), pthread_self());
    while(1) {
        pthread_mutex_lock(&worker->threadpool->jobs_mutex);

        while(worker->threadpool->jobs == NULL) {
            if(worker->treminate) break;
            pthread_cond_wait(&worker->threadpool->jobs_cond, &worker->threadpool->jobs_mutex);
        }
        if(worker->treminate) break;

        job_t *jober = worker->threadpool->jobs;
        if(jober != NULL) {
            LL_REMOVE(jober, worker->threadpool->jobs);
        }
        pthread_mutex_unlock(&worker->threadpool->jobs_mutex);

        if(jober == NULL) continue;

        jober->func(jober);
    }
    free(worker);
    pthread_exit(NULL);
}

在线程里面，我们主要就是取任务，如果没有任务，我们就等待，如果有设置terminate, 我们就退出。取到了任务之后，我们就执行任务队列的回调函数。

任务回调函数

static void client(job_t *arg) {
    int index = *(int*)arg->userdata;

    printf("index: %d, selfid: %lu\n", index, pthread_self());

    free(arg->userdata);
    free(arg);
}

我们的任务处理函数很简单，主要对传进来的参数进行读取。

整个code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

 #include <sys/types.h>
 #include <sys/syscall.h>


#define LL_ADD(item, list) do { \
        item->prev = NULL;      \
        item->next = list;      \
        list = item;            \
}while(0)

#define LL_REMOVE(item, list) do {  \
        if(item->prev != NULL) item->prev->next = item->next;   \
        if(item->next != NULL) item->next->prev = item->prev;   \
        if(item == list) list = item->next;                     \
        item->prev = item->next = NULL;                         \
}while(0)


typedef struct work {
    pthread_t thread;
    int treminate;
    struct workqueue *threadpool;

    struct work *prev;
    struct work *next;
}work_t;

typedef struct job {
    void (*func)(struct job *arg); 
    void *userdata;

    struct job *prev;
    struct job *next;
}job_t;

typedef struct workqueue{
    struct work *works;
    struct job  *jobs;

    pthread_cond_t jobs_cond;
    pthread_mutex_t jobs_mutex;
}threadpool;

static void *ThreadFunc(void *arg) {
    work_t *worker = (work_t*)arg;
    printf("pid :%u, tid: %ld, self: %lu\n", getpid(), (long int)syscall(__NR_gettid), pthread_self());
    while(1) {
        pthread_mutex_lock(&worker->threadpool->jobs_mutex);

        while(worker->threadpool->jobs == NULL) {
            if(worker->treminate) break;
            pthread_cond_wait(&worker->threadpool->jobs_cond, &worker->threadpool->jobs_mutex);
        }
        if(worker->treminate) break;

        job_t *jober = worker->threadpool->jobs;
        if(jober != NULL) {
            LL_REMOVE(jober, worker->threadpool->jobs);
        }
        pthread_mutex_unlock(&worker->threadpool->jobs_mutex);

        if(jober == NULL) continue;

        jober->func(jober);
    }
    free(worker);
    pthread_exit(NULL);
}

int ThreadPoolCreate(threadpool *pool, int numWorks) {
    if(numWorks < 1) numWorks = 1;
    memset(pool, 0, sizeof(threadpool));

    pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;
    pthread_mutex_t bland_mutex = PTHREAD_MUTEX_INITIALIZER;

    memcpy(&pool->jobs_cond, &blank_cond, sizeof(pool->jobs_cond));
    memcpy(&pool->jobs_mutex, &bland_mutex, sizeof(pool->jobs_mutex));

    for (int i = 0; i < numWorks; ++i) {
        work_t *worker =  (work_t *)calloc(1, sizeof(work_t));
        if(worker == NULL) {
            perror("calloc");
            return -1;
        }
        worker->threadpool = pool;

        int ret = pthread_create(&worker->thread, NULL, ThreadFunc, (void *)worker);
        
        if(ret) {
            perror("pthread_create");
            free(worker);
            return -1;
        }

        LL_ADD(worker, worker->threadpool->works);
    }

    return 0;
}

void ThreadPoolDestory(threadpool *pool){
    work_t *worker = NULL;

    for(worker = pool->works; worker != NULL; worker = worker->next) {
        worker->treminate = 1;
    }
    pthread_mutex_lock(&pool->jobs_mutex);

    pool->works = NULL;
    pool->jobs = NULL;

    pthread_cond_broadcast(&pool->jobs_cond);
    pthread_mutex_unlock(&pool->jobs_mutex);
}

static void client(job_t *arg) {
    int index = *(int*)arg->userdata;

    printf("index: %d, selfid: %lu\n", index, pthread_self());

    free(arg->userdata);
    free(arg);
}

void ThreadPoolQueue(threadpool *pool, job_t *job) {
    pthread_mutex_lock(&pool->jobs_mutex);

    LL_ADD(job, pool->jobs);

    pthread_cond_signal(&pool->jobs_cond);
    pthread_mutex_unlock(&pool->jobs_mutex);
} 

int main(int argc, char **argv) {
    threadpool pool;
    if(argc < 1) {
        printf("usage:%d\n", argc);
        return -1;
    }
    int numworks = atoi(argv[1]);

    ThreadPoolCreate(&pool, numworks);
    for(int i = 0; i < numworks; ++i) {
        job_t *jober = (job_t*)calloc(1, sizeof(job_t));
        if(jober == NULL) {
            perror("calloc");
            return -1;
        }

        jober->func = client;
        jober->userdata = calloc(1, sizeof(int));
        *(int *)jober->userdata = i;
        ThreadPoolQueue(&pool, jober);       
    }
    getchar();
	printf("\n");
    
    //ThreadPoolDestory(&pool->thread);
    return 0;
}

code2:

threadpool.h

#include <pthread.h>

struct job
{
    void* (*callback_function)(void *arg);    //线程回调函数
    void *arg;                                //回调函数参数
    struct job *next;
};

struct threadpool
{
    int thread_num;                   //线程池中开启线程的个数
    int queue_max_num;                //队列中最大job的个数
    struct job *head;                 //指向job的头指针
    struct job *tail;                 //指向job的尾指针
    pthread_t *pthreads;              //线程池中所有线程的pthread_t
    pthread_mutex_t mutex;            //互斥信号量
    pthread_cond_t queue_empty;       //队列为空的条件变量
    pthread_cond_t queue_not_empty;   //队列不为空的条件变量
    pthread_cond_t queue_not_full;    //队列不为满的条件变量
    int queue_cur_num;                //队列当前的job个数
    int queue_close;                  //队列是否已经关闭
    int pool_close;                   //线程池是否已经关闭
};

//================================================================================================
//函数名：                   threadpool_init
//函数描述：                 初始化线程池
//输入：                    [in] thread_num     线程池开启的线程个数
//                         [in] queue_max_num  队列的最大job个数 
//输出：                    无
//返回：                    成功：线程池地址 失败：NULL
//================================================================================================
struct threadpool* threadpool_init(int thread_num, int queue_max_num);

//================================================================================================
//函数名：                    threadpool_add_job
//函数描述：                  向线程池中添加任务
//输入：                     [in] pool                  线程池地址
//                          [in] callback_function     回调函数
//                          [in] arg                     回调函数参数
//输出：                     无
//返回：                     成功：0 失败：-1
//================================================================================================
int threadpool_add_job(struct threadpool *pool, void* (*callback_function)(void *arg), void *arg);

//================================================================================================
//函数名：                    threadpool_destroy
//函数描述：                   销毁线程池
//输入：                      [in] pool                  线程池地址
//输出：                      无
//返回：                      成功：0 失败：-1
//================================================================================================
int threadpool_destroy(struct threadpool *pool);

//================================================================================================
//函数名：                    threadpool_function
//函数描述：                  线程池中线程函数
//输入：                     [in] arg                  线程池地址
//输出：                     无  
//返回：                     无
//================================================================================================
void* threadpool_function(void* arg);

threadpool.cpp

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <sys/time.h>
#include <unistd.h>
#include <iostream>
#include <sstream>
#include "threadpool.h"

using namespace std;



#define TASK_NUMBER 100

struct threadpool *threadpool_init(int thread_num, int queue_max_num)
{
    struct threadpool *pool = NULL;
    do
    {
        pool = (struct threadpool *)malloc(sizeof(struct threadpool));
        if (NULL == pool)
        {
            printf("failed to malloc threadpool!\n");
            break;
        }
        pool->thread_num = thread_num;
        pool->queue_max_num = queue_max_num;
        pool->queue_cur_num = 0;
        pool->head = NULL;
        pool->tail = NULL;
        if (pthread_mutex_init(&(pool->mutex), NULL))
        {
            printf("failed to init mutex!\n");
            break;
        }
        if (pthread_cond_init(&(pool->queue_empty), NULL))
        {
            printf("failed to init queue_empty!\n");
            break;
        }
        if (pthread_cond_init(&(pool->queue_not_empty), NULL))
        {
            printf("failed to init queue_not_empty!\n");
            break;
        }
        if (pthread_cond_init(&(pool->queue_not_full), NULL))
        {
            printf("failed to init queue_not_full!\n");
            break;
        }
        pool->pthreads = (pthread_t *)malloc(sizeof(pthread_t) * thread_num);
        if (NULL == pool->pthreads)
        {
            printf("failed to malloc pthreads!\n");
            break;
        }
        pool->queue_close = 0;
        pool->pool_close = 0;
        int i;
        for (i = 0; i < pool->thread_num; ++i)
        {
            pthread_create(&(pool->pthreads[i]), NULL, threadpool_function, (void *)pool);
        }

        return pool;
    } while (0);

    return NULL;
}

int threadpool_add_job(struct threadpool *pool, void *(*callback_function)(void *arg), void *arg)
{
    assert(pool != NULL);
    assert(callback_function != NULL);
    assert(arg != NULL);

    pthread_mutex_lock(&(pool->mutex));
    while ((pool->queue_cur_num == pool->queue_max_num) && !(pool->queue_close || pool->pool_close))
    {
        pthread_cond_wait(&(pool->queue_not_full), &(pool->mutex)); //队列满的时候就等待
    }
    if (pool->queue_close || pool->pool_close) //队列关闭或者线程池关闭就退出
    {
        pthread_mutex_unlock(&(pool->mutex));
        return -1;
    }
    struct job *pjob = (struct job *)malloc(sizeof(struct job));
    if (NULL == pjob)
    {
        pthread_mutex_unlock(&(pool->mutex));
        return -1;
    }
    pjob->callback_function = callback_function;
    pjob->arg = arg;
    pjob->next = NULL;
    if (pool->head == NULL)
    {
        pool->head = pool->tail = pjob;
        pthread_cond_broadcast(&(pool->queue_not_empty)); //队列空的时候，有任务来时就通知线程池中的线程：队列非空
    }
    else
    {
        pool->tail->next = pjob;
        pool->tail = pjob;
    }
    pool->queue_cur_num++;
    pthread_mutex_unlock(&(pool->mutex));
    return 0;
}

static uint64_t get_tick_count()
{
    struct timeval tval;
    uint64_t ret_tick;

    gettimeofday(&tval, NULL);

    ret_tick = tval.tv_sec * 1000L + tval.tv_usec / 1000L;
    return ret_tick;
}

void *threadpool_function(void *arg)
{
    struct threadpool *pool = (struct threadpool *)arg;
    struct job *pjob = NULL;
    uint64_t start_time = get_tick_count();
    uint64_t end_time = get_tick_count();
    while (1) //死循环
    {
        pthread_mutex_lock(&(pool->mutex));
        while ((pool->queue_cur_num == 0) && !pool->pool_close) //队列为空时，就等待队列非空
        {
            end_time = get_tick_count();    // 没有任务的时候设置读取最后处理任务的时间
            printf("threadpool need time:%lums\n", end_time - start_time);
            pthread_cond_wait(&(pool->queue_not_empty), &(pool->mutex));
        }
        if (pool->pool_close) //线程池关闭，线程就退出
        {
            pthread_mutex_unlock(&(pool->mutex));
            pthread_exit(NULL);
        }
        pool->queue_cur_num--;
        pjob = pool->head;
        if (pool->queue_cur_num == 0)
        {
            pool->head = pool->tail = NULL;
        }
        else
        {
            pool->head = pjob->next;
        }
        if (pool->queue_cur_num == 0)
        {
            pthread_cond_signal(&(pool->queue_empty)); //队列为空，就可以通知threadpool_destroy函数，销毁线程函数
        }
        if (pool->queue_cur_num == pool->queue_max_num - 1)
        {
            pthread_cond_broadcast(&(pool->queue_not_full)); //队列非满，就可以通知threadpool_add_job函数，添加新任务
        }
        pthread_mutex_unlock(&(pool->mutex));

        (*(pjob->callback_function))(pjob->arg); //线程真正要做的工作，回调函数的调用
        free(pjob);
        pjob = NULL;
    }
}
int threadpool_destroy(struct threadpool *pool)
{
    assert(pool != NULL);
    pthread_mutex_lock(&(pool->mutex));
    if (pool->queue_close || pool->pool_close) //线程池已经退出了，就直接返回
    {
        pthread_mutex_unlock(&(pool->mutex));
        return -1;
    }

    pool->queue_close = 1; //置队列关闭标志
    while (pool->queue_cur_num != 0)
    {
        pthread_cond_wait(&(pool->queue_empty), &(pool->mutex)); //等待队列为空
    }

    pool->pool_close = 1; //置线程池关闭标志
    pthread_mutex_unlock(&(pool->mutex));
    pthread_cond_broadcast(&(pool->queue_not_empty)); //唤醒线程池中正在阻塞的线程
    pthread_cond_broadcast(&(pool->queue_not_full));  //唤醒添加任务的threadpool_add_job函数
    int i;
    for (i = 0; i < pool->thread_num; ++i)
    {
        pthread_join(pool->pthreads[i], NULL); //等待线程池的所有线程执行完毕
    }

    pthread_mutex_destroy(&(pool->mutex)); //清理资源
    pthread_cond_destroy(&(pool->queue_empty));
    pthread_cond_destroy(&(pool->queue_not_empty));
    pthread_cond_destroy(&(pool->queue_not_full));
    free(pool->pthreads);
    struct job *p;
    while (pool->head != NULL)
    {
        p = pool->head;
        pool->head = p->next;
        free(p);
    }
    free(pool);
    return 0;
}



// #define random(x) (rand()%x)

static string int2string(uint32_t user_id)
{
    stringstream ss;
    ss << user_id;
    return ss.str();
}

int main(int argc, char *argv[])
{

    thread_num = atoi(argv[1]);


    printf("thread_num = %d,\n", thread_num);
    struct threadpool *pool = threadpool_init(thread_num, TASK_NUMBER); // 初始化线程
    for (int i = 0; i < TASK_NUMBER; i++)
    {
        if (use_pool)       // 使用连接池时任务采用workUsePool
        {
            threadpool_add_job(pool, work, (void *)pDBPool);
        }
        else                // 不使用连接池时任务采用workNoPool
        {
            threadpool_add_job(pool, work, (void *)pDBPool);
        }
    }

    while(pool->queue_cur_num !=0 )     // 判断队列是否还有任务
    {
         sleep(1);  // 还有任务主线程继续休眠
    }
    sleep(2);       // 没有任务要处理了休眠2秒退出，这里等待主要是确保所有线程都已经空闲
    threadpool_destroy(pool);

    delete pDBPool;
    return 0;
}
birate_小小人生
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
池式结构（3）
qq_34130311的博客
11-17 154
本文主要讲内存池的原理和实现 池式结构的作用： 主要起到缓冲作用。也就是需要使用资源时，在已有的资源结构中去拿，避免重新创建资源。 背景: 在网络数据中，建立io连接后，recv收到数据后，会讲数据放置在buffer中。若数据周期较长，或者将处理数据进行解耦，放置在另一个线程中处理，这样buffer就是不可用的。我们通常会malloc一个内存，将数据拷贝进去，再在新线程中 处理数据。 问题： 当大量io事件发生时，会出现： 1、不利于内存管理； 2、内存碎片； 什么是内存池？ 拿取内存时，从内存池中拿取内存
APScheduler.pptx
06-24
3. **执行器 (executors)**：执行器负责将任务提交到线程池或进程池中运行。常见的执行器包括： - **ThreadPoolExecutor**：使用线程池执行任务，适合 I/O 密集型任务。 - **ProcessPoolExecutor**：使用进程池...
【池式结构】连接池、线程池、内存池、异步请求池
Leoh的博客
02-21 1034
池式结构
池式结构--异步池
Birate的博客
04-05 170
异步和同步的区别就是可以不需要一直等待IO，有结果就返回数据。 异步池主要关注以下几点: 具有多个连接 使用网络io的基础，发送对应的协议 多个连接，发送完请求之后，fd使用epoll去管理。 请求与相应的线程，不能放到一个线程去处理。 异步池可以分以下思路进行处理: 1. commit: 请求 * 建立网络连接 * 组织好对应的协议，如dns * 发送到对应的服务器 * fd是否可读，fd加入epoll int dns_async_client_commit(struct async_context
池式结构--内存池
Birate的博客
08-08 319
文章目录内存管理伙伴算法slab算法内存池的实现1. 分配2. 释放3. 扩容 内存管理 我们经常在堆上进行内存的分配和释放时，就会产生内存碎片问题。 内部碎片的产生：因为所有的内存分配必须起始于可被 4、8 或 16 整除（视 处理器体系结构而定）的地址或者因为MMU的分页机制的限制，决定内存分配算法仅能把预定大小的内存块分配给客户。假设当某个客户请求一个 43 字节的内存块时，因为没有适合大小的内存，所以它可能会获得 44字节、48字节等稍大一点的字节，因此由所需大小四舍五入而产生的多余空间就叫内部碎
池式结构-连接池
xiexiaojing的博客
01-08 475
分布式协调系统如zookeeper、etcd，客户端都是使用一个长连接。记得之前使用k8s客户端(核心是etcd)时候，需要自己实现close()接口，我在close接口里判断如果连接断了...
深入剖析池式基础组件---------线程池（手撕线程池代码）
最新发布
weixin_70084230的博客
08-28 218
深入剖析池式基础组件---------线程池（手撕线程池代码）
004.池式结构之线程池
richy_的博客
06-09 69
池式结构之线程池
java--线程池技术汇总
weixin_50492747的博客
06-13 142
我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。通常情况下，创建线程是需要一定的耗时的，设这个时间为T1，而连接后读/写服务的时间为T2，当T1>>T2时，我们就应当考虑一种策略或者机制来控制，使得服务对于第二种请求方式也能在较低的功耗下完成。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池。
【45-线程的实现方式-线程池的创建方式-线程池的执行顺序-CompletableFutrue异步处理】
Coder_ljw的博客
12-04 533
【45-线程的实现方式-线程池的创建方式-线程池的执行顺序-CompletableFutrue异步处理】实现Runnable接口、Callable接口线程池、创建线程的实现方式面的三种获取线程的方法是直接获取，这时可以通过线程池来更加高效的管理线程对象。然后我们就可以通过这个线程池对象来获取对应的线程通过上面的介绍我们发现获取线程的方式继承Thread对象和实现Runnable接口没有办法获取返回结果的，实现Callable接口可以获取线程的返回结果。当然这三种方式都不能控制我们的资源，线程池可以控制资源。
18.【线程池、Lambda表达式】_java线程_lambda线程池_meantbs3_
10-03
此外，Java 5及以上版本还提供了`Executors`工厂类，方便快速创建不同类型的线程池，如固定大小线程池、单线程池和缓存线程池等。 接着，我们讨论Lambda表达式。Lambda表达式是Java 8引入的一个重要特性，它是一种...
springboot +mybatis(durid的数据库连接池)+freemarker--可能我freemaker的依赖没有加到时候自己再pom文件下加一下
04-07
Spring Boot集成了许多常用组件，包括自动配置、内嵌式Web服务器、健康检查等，使得开发者能够快速构建可部署的应用。本项目结合了MyBatis作为持久层框架，以及Durid作为数据库连接池，进一步优化了数据库操作的性能...
jboss-5.1.0.GA 下载地址
06-07
10. **性能优化**：通过线程池管理、内存优化、连接池配置等手段，JBoss AS 5.1.0.GA提供了良好的性能表现，适合大规模企业应用。 11. **社区支持**：作为开源项目，JBoss AS 5.1.0.GA拥有活跃的社区，开发者可以...
多线程式web服务器
01-07
线程池预先创建一定数量的线程，当有新的请求时，从池中获取空闲线程处理，完成后归还到池中。这样可以控制系统的资源消耗，提高响应速度。 2. **请求分发**：线程池中的线程需要合理地分配给请求。一种常见的策略...
c++深拷贝(两种)和浅拷贝
Birate的博客
05-29 7923
文章目录1.深拷贝和浅拷贝2. 移动构造函数(std::move())3.左值和右值 c++的拷贝有两种：即深拷贝和浅拷贝. 1.深拷贝和浅拷贝 在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的；但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象，所以，此时，必须采用深拷贝。 深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来
C++逆波兰算法
Birate的博客
11-30 5263
逆波兰表达式又叫做后缀表达式。 在通常的表达式中，二元运算符总是置于与之相关的两个运算对象之间，这种表示法也称为中缀表示。波兰逻辑学家J.Lukasiewicz于1929年提出了另一种表示表达式的方法，按此方法，每一运算符都置于其运算对象之后，故称为后缀表示式。 逆波兰是一种十分有用的表达式，它将复杂表达式转换为可以依靠简单的操作得到计算结果的表达式。例如(a+b)*(c+d)转换为ab+c...
CMake
Birate的博客
04-30 3972
CMake 文章目录CMake1. 最简单的CMake2. 添加message信息3. 添加链接库4. 链接第三方库5. 变量与缓存6. 跨平台和编译器7. 分支和判断8. 变量和作用域 我们使用的cmake版本为3.x 以上。 首先我们熟悉基本的命令: cmake -B build // 在源码目录用 -B 直接创建 build 目录并生成 build/Makefile cmake --build build -j4
关于C++中的getline(cin,string)和cin的几点区别
Birate的博客
03-07 2982
1. cin&gt;&gt;s: cin&gt;&gt;是由两部分构成的，cin和&gt;&gt;,其中cin是输入流istream类的一个对象，隶属于iostream函数库 而&gt;&gt;则是运算符：这个运算符的作用是：从左侧cin对象中读取数据，并将它赋给右侧的运算对象. 1.&gt;&gt;运算符是由右侧的数据类型定义的，右侧的数据类型不同，重载的&gt;&gt;也不同 2.&gt;&g
死锁的检测与实现
Birate的博客
04-10 1646
死锁的发生是由于线程间资源争夺引起的，这里不对线程的死锁的概念和原理解释。主要介绍死锁的检测和具体实现，检测我们可以使用一个有向图来表示， 线程 A 获取线程 B 已占用的锁，则为线程 A 指向线程 B。 如何为线程 B 已占用的锁？运行过程线程 B 获取成功的锁。检测的原理采用另一个线程定时对图进程检测是否有环的存在。 数据结构定义: typedef enum { PROCESS, RESOURCE} Type; // 定义资源的类型 typedef struct source_type_t { /
Python定时任务库APScheduler详解
执行器负责将任务提交到线程池或进程池中执行。这使得APScheduler能够在多线程或多进程环境中高效运行任务，同时保持对系统资源的良好管理。执行器的类型包括ThreadPoolExecutor和ProcessPoolExecutor，分别对应线程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值