apr_thread使用内存之谜

于 2022-08-02 21:05:29 发布
阅读量269 收藏
点赞数
文章标签： linux 内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mimiduck/article/details/126119443
版权

问题起因

问题的起因是因为使用了一个apr的服务，产生了巨大的virtual memory，具体的表现是，在top中可以看到该进程的VIRT和RES，VIRT比实际上使用的要大很多。

在google上找到如下文章

https://lists.apache.org/thread/yvwxmssr90y2nnozj949w5gsg9gpxn1p

怕有人访问不了，直接把原文贴在这里

I have noticed that my multithreaded APR program consumes a *very*
large amount of virtual memory per thread and I can't think of a
reason why. I am running Debian 3.1 (latest kernel 2.6.8-3-686) and I
tried the test program below with both the APR 0.9.x that comes with
Debian and with the latest APR 1.2.x version.
我注意到多线程的APR程序每一个线程会消耗很大的virtual memory，我没有想明白是为什么。
我使用的是Debian 3.1的系统，基于apr版本 APR 0.9.x和 APR 1.2.x

In both cases I end up with around 800 MB of virtual RAM for 100 threads:
20385 ivanr 16 0 802m 956 1800 S 0.0 0.4 0:00.02 test
在如下两个例子中，运行100个线程大致使用了800MBvirtual RAM

Am I doing something wrong or is this a bug? Any help is greatly appreciated!

void* APR_THREAD_FUNC thread_worker(apr_thread_t *thread, void *data) {
apr_thread_exit(thread, 0);
}

int main(int argc, const char * const argv[]) {
apr_pool_t *pool;
int i;

apr_app_initialize(&argc, &argv, NULL);
atexit(apr_terminate);

apr_pool_create(&pool, NULL);

for(i = 0; i < 100; i++) {
apr_thread_t *thread = NULL;
apr_thread_create(&thread, NULL, thread_worker, NULL, pool);
}

apr_sleep(1000 * 1000 * 1000);
}

VIRT & RES & SHR

如果你执行top看一下进程的内存占用，会得到如下几列

  • VIRT
    它是程序“需要”内存的总和，包含了加载的动态库内存，与其他进程共享的内存，以及分配给他的内存；
    但是如果程序申请了100m但是仅仅使用了10m，这里还是按照100m计算统计

  • RES
    它是程序正在使用内存的总和，一个主要区别是如果程序申请了100m但是仅仅使用了10m，这里是按照10m计算统计

  • SHR
    加载的库的内存，如果仅仅是使用库里的一些函数，但是整个库还是会加载入内存。

一个“空白”程序，如下，它会占用多少VIRT,RES,SHR?

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

    return 0;
}

在这里插入图片描述
它占用了4164kB的VIRT， 368KB的RES, 268KB的SHR。

SHR基本上为动态库加载。一个“什么都没有的"c程序，基础的链接是这样的
在这里插入图片描述

那么程序”自身“多大呢？ RES-SHR = 368- 268 = 100KB

程序总共”需要“的大小 VIRT = 4164kB

如果我们申请1m内存再释放它，是否可以跟上述程序暂用内存一致呢？
来试一下

int main(int argc, const char * const argv[]) {
    char *p = (char *)calloc(1048576, sizeof(char)); 
    free(p); // break 1
    return 0; // break 2
}

这里我们增加2个断点，来观察内存使用的变化；

break1

在这里插入图片描述
与上面”空白“程序相比，此时RES是增加1k； 但是VIRT也增长了1k

break2在这里插入图片描述

与上面”空白“程序相比，VIRT是回到了原点。 RES仍有所增加，但是可以理解，毕竟多了几行代码，code也是要占用空间的；
SHR也增加了一点（这个是为什么？）

换成malloc呢？

int main(int argc, const char * const argv[]) {
    char *p;
    for (int i=0; i<1048576; i++)
        p = malloc(sizeof(char));
    //free(p);
    return 0;
}

在不释放内存的情况下，RES可以涨到33M；VIRT涨到37M
在这里插入图片描述

在释放后，内存情况大体也相当； 说明多次调用malloc还是有一定开销的。（这里换成calloc也一样）

int main(int argc, const char * const argv[]) {
    char *p;
    for (int i=0; i<1048576; i++) {
        p = malloc(sizeof(char));
        free(p);
    }
    return 0;
}

在这里插入图片描述

apr_thread测试

1. 使用样例代码（不做thread_join）

上面的帖子跟遇到的情况有些类似，所以我把他的样例程序跑了一下

#include <apr-1/apr.h>
#include <apr-1/apr_pools.h>
#include <apr-1/apr_thread_proc.h>

#define THREAD_NUM 100

void* APR_THREAD_FUNC thread_worker(apr_thread_t *thread, void *data) {
apr_thread_exit(thread, 0);
}

int main(int argc, const char * const argv[]) {
    apr_pool_t *pool;
    int i;
    apr_status_t status = 0;

    apr_app_initialize(&argc, &argv, NULL);
    atexit(apr_terminate);

    apr_pool_create(&pool, NULL);

    apr_thread_t *thread[THREAD_NUM];
    for(i = 0; i < THREAD_NUM; i++) {
        apr_thread_create(&thread[i], NULL, thread_worker, NULL, pool);
    }

    apr_sleep(1000 * 1000 * 1000);
}

样例中运行100个apr_thread

这个是样例代码的结果。

在这里插入图片描述
可以看到RES仅仅1.7M，但是VIRT确实906M，将近一个G了。这个差距也太大了。确实有文章里说的问题。

2. 执行thread_join

如果将所有线程join，如下

#define THREAD_NUM 100

void* APR_THREAD_FUNC thread_worker(apr_thread_t *thread, void *data) {
apr_thread_exit(thread, 0);
}

int main(int argc, const char * const argv[]) {
    apr_pool_t *pool;
    int i;
    apr_status_t status = 0;

    apr_app_initialize(&argc, &argv, NULL);
    atexit(apr_terminate);

    apr_pool_create(&pool, NULL);

    apr_thread_t *thread[THREAD_NUM];
    for(i = 0; i < THREAD_NUM; i++) {
        apr_thread_create(&thread[i], NULL, thread_worker, NULL, pool);
    }

    // 
    for(i = 0; i < THREAD_NUM; i++) {
        apr_thread_join(&status, thread[i]);
    }

    apr_sleep(1000 * 1000 * 1000);

    return 0;
}

RES1.3M，几乎差不多；VIRT120M，比不join少了很多；但是仍有近100倍差距
在这里插入图片描述

3. 再做apr_pool_clear

如果在thread_join后面再调用apr_pool_clear(pool)，主动clear一下pool呢？

在这里插入图片描述
几乎没有变化。

4. 移除apr_thread_exit

既然最后都有thread_join,把线程中的apr_thread_exit移除试试呢？

代码如下

#define THREAD_NUM 100

void* APR_THREAD_FUNC thread_worker(apr_thread_t *thread, void *data) {
//apr_thread_exit(thread, 0);
return NULL;
}

int main(int argc, const char * const argv[]) {
    apr_pool_t *pool;
    int i;
    apr_status_t status = 0;

    apr_app_initialize(&argc, &argv, NULL);
    atexit(apr_terminate);

    apr_pool_create(&pool, NULL);

    apr_thread_t *thread[THREAD_NUM];
    for(i = 0; i < THREAD_NUM; i++) {
        apr_thread_create(&thread[i], NULL, thread_worker, NULL, pool);
    }

    for(i = 0; i < THREAD_NUM; i++) {
        apr_thread_join(&status, thread[i]);
    }

    apr_sleep(1000 * 1000 * 1000);

    return 0;
}

对比发现；RES和SHR几乎没有变化；但是VIRT居然只有52M，比之前少了一半还多。

在这里插入图片描述

这么看来，如果最后有join的动作，还是不要执行apr_thread_exit的比较节省内存。

5. 将线程detach运行

#define THREAD_NUM 100

void* APR_THREAD_FUNC thread_worker(apr_thread_t *thread, void *data) {
//apr_thread_exit(thread, 0);
return NULL;
}

int main(int argc, const char * const argv[]) {
    apr_pool_t *pool;
    int i;
    apr_status_t status = 0;
    apr_threadattr_t *thread_attr;

    apr_app_initialize(&argc, &argv, NULL);
    atexit(apr_terminate);

    apr_pool_create(&pool, NULL);
    apr_threadattr_create(&thread_attr, pool);
    apr_threadattr_detach_set(thread_attr, 1);

    apr_thread_t *thread[THREAD_NUM];
    for(i = 0; i < THREAD_NUM; i++) {
        assert(apr_thread_create(&thread[i], thread_attr, thread_worker, NULL, pool)==APR_SUCCESS);
    }

    apr_sleep(1000 * 1000 * 1000);

    return 0;
}

与joinable的thread几乎一样。
在这里插入图片描述
如果还原apr_thread_exit，也跟joinable的thread几乎一样

在这里插入图片描述
所以detach对内存几乎没有影响。

6. 限制thread的栈大小

#define THREAD_NUM 100

void* APR_THREAD_FUNC thread_worker(apr_thread_t *thread, void *data) {
//apr_thread_exit(thread, 0);
return NULL;
}

int main(int argc, const char * const argv[]) {
    apr_pool_t *pool;
    int i;
    apr_status_t status = 0;
    apr_threadattr_t *thread_attr;

    apr_app_initialize(&argc, &argv, NULL);
    atexit(apr_terminate);

    apr_pool_create(&pool, NULL);
    apr_threadattr_create(&thread_attr, pool);
    //apr_threadattr_detach_set(thread_attr, 1);
    apr_threadattr_stacksize_set(thread_attr,10240); //10k

    apr_thread_t *thread[THREAD_NUM];
    for(i = 0; i < THREAD_NUM; i++) {
        assert(apr_thread_create(&thread[i], thread_attr, thread_worker, NULL, pool)==APR_SUCCESS);
    }

    for(i = 0; i < THREAD_NUM; i++) {
        apr_thread_join(&status, thread[i]);
    }

    apr_sleep(1000 * 1000 * 1000);

    return 0;
}

每一个线程的栈大小限制为10k，好像没有什么变化？？
在这里插入图片描述

每个thread的栈默认是多少呢？ 一般来说，默认为8M,即8,388,608bytes

可以通过ulimit -s或者ulimit -a看一下
在这里插入图片描述
可以通过**apr_threadattr_stacksize_set(thread_attr,8388608);**来还原一下默认值，跑出来结果跟不设置差不多，VIRT为52M;

在这里插入图片描述
好像真没有什么变化。

pthread测试

作为对比，我们同样的使用pthread来做一轮测试

1. 不做pthread_join

#include <pthread.h>
#include <assert.h>
#include <zconf.h>

#define THREAD_NUM 100

static void *thread_worker(void *data) {
    pthread_exit(NULL);
    return NULL;
}

int main(int argc, const char *const argv[]) {
    int i = 0;
    pthread_t thread[THREAD_NUM];
    for (i = 0; i < THREAD_NUM; i++) {
        assert(pthread_create(&thread[i], NULL, thread_worker, NULL) == 0);
    }

    sleep(1000000);
    
    return 0;
}

与apr_thread对比，VIRT893M 基本相当； RES 1.2M比之前的1.7M了一点；SHR 0.4M也小了一点；

在这里插入图片描述

注释掉 pthread_exit的结果如下：
VIRT826M,RES 1.1M,SHR 0.4M
在这里插入图片描述

做pthread_join

static void *thread_worker(void *data) {
    pthread_exit(NULL);
    return NULL;
}

int main(int argc, const char *const argv[]) {
    int i = 0;
    pthread_t thread[THREAD_NUM];
    for (i = 0; i < THREAD_NUM; i++) {
        assert(pthread_create(&thread[i], NULL, thread_worker, NULL) == 0);
    }

    for (i = 0; i < THREAD_NUM; i++) {
        pthread_join(thread[i], NULL);
    }

    sleep(1000000);

    return 0;
}

相比apr_thread，VIRT 106M/ RES 0.7M/SHR 0.5M 都小一些
在这里插入图片描述

3. 去除pthread_exit

#define THREAD_NUM 100

static void *thread_worker(void *data) {
    //pthread_exit(NULL);
    return NULL;
}

int main(int argc, const char *const argv[]) {
    int i = 0;
    pthread_t thread[THREAD_NUM];
    for (i = 0; i < THREAD_NUM; i++) {
        assert(pthread_create(&thread[i], NULL, thread_worker, NULL) == 0);
    }

    for (i = 0; i < THREAD_NUM; i++) {
        pthread_join(thread[i], NULL);
    }

    sleep(1000000);

    return 0;
}

在这里插入图片描述

5. 限制stacksize

#define THREAD_NUM 100

static void *thread_worker(void *data) {
    //pthread_exit(NULL);
    return NULL;
}

int main(int argc, const char *const argv[]) {
    int i = 0;
    int stacksize = 10240;
    pthread_t thread[THREAD_NUM];
    pthread_attr_t  attr;
    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr, stacksize);
    for (i = 0; i < THREAD_NUM; i++) {
        assert(pthread_create(&thread[i], &attr, thread_worker, NULL) == 0);
    }

    pthread_attr_destroy(&attr);
    sleep(1000000);

    return 0;
}

相对于不设置大小，内存各项指标基本不变。(同apr_thread结果)
在这里插入图片描述

6. 结论

pthread的内存占用略比apr_thead少，但是整体都出现VIRT比RES大几百倍的情况; 尤其是pthread_exit的使用，似乎对VIRT的参数影响较大。

优化解决方案

安安爸Chris
关注
apr-1.7.0-apr_escape_test_char.h.zip
10-01
编译 apr 1.7.0 需要的头文件 apr_escape_test_char.h --------------------- /* this file is automatically generated by gen_test_char, do not edit. "make include/private/apr_escape_test_char.h" to ...
apr线程使用
xiao2macf的专栏
05-27 630
主要对apr 线程作一下简单介绍，涉及apr_thread_t、apr_thread_mutex_t、apr_thread_cond_t等的使用。
在linux32上编译c程序，依赖apr的库，碰到的编译问题
javavsnet
01-23 370
 在linux32上编译c程序，程序依赖apr，在编译时出现下面的错误：   /apr-1/apr.h:358: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘apr_off_t’   经过调查，发现是在32位机器上，编译c程序时需要说明要支持大文件，给CFLAGS增加设置 CFLAGS=-D_LARGEF...
apr---接口篇
幽雨雨幽
08-08 2655
apr　:　Apache Portable Runtime apr 接口详见：http://apr.apache.org/docs/apr/2.0/group__apr__thread__proc.html#ga1426acc5bdd96385769e7b42bfa6ebbd Library initialization and termination : 1.apr_statu...
C++封装一个简单的线程类
zs10hz的专栏
08-05 882
多线程编程简介：     大家在编程时，经常需要在程序中启动一个或多个线程来处理任务，而如果每次都是去调用系统创建线程的API函数来创建，代码量虽不多，但线程的创建和业务逻辑代码就揉在一起了，且创建多个线程的时候，有大量的重复代码，不便于维护。若我们把创建线程和销毁线程的这些共同的代码封装到一个类中，这样我们可以更专注业务逻辑的实现，在其它地方直接拿来用就行，程序也便于维护和扩展。而且这样的
APR介绍
热门推荐
zhuky的专栏
12-16 1万+
APR分析-整体篇由于部门所使用的底层库与Apache Server有着“一定的渊源”，所以总有一种想看看Apache的实现的冲动。最近项目收尾，愿望终可实现。一、何为APR?Apache Server经过这么多年的发展后，将一些通用的运行时接口封装起来提供给大家，这就是Apache Portable Run-time libraries, APR。二、APR的目录组织从www
apr多线程
流彩飞霞的专栏
03-18 1416
在线程同步方面，Posix标准定义了3种同步模型，分别为互斥量、条件变量和读写锁。APR也“浅”封装了这3种模型，只是在“读写锁”一块儿还没有全部完成。 线程同步的源代码的位置在$(APR_HOME)/locks目录下，本篇blog着重分析unix子目录下的thread_mutex.c、thread_rwlock.c和thread_cond.c文件的内容，其相应头文件为(APR_
apr_mcast.rar_apr_apr_
09-21
6. **处理多路复用**：由于组播可能会有多个数据源，所以需要使用`apr_pollset_add()`将套接字添加到Apr的pollset中，然后使用`apr_pollset_poll()`进行多路复用，以便同时处理多个事件。 在实际应用中，可能还需要...
APR内存池概述.zip_APR内存池概述_apr内存池_内存池
09-23
APR内存池，全称Apache Portable Runtime（阿帕奇可移植运行时）内存池，是阿帕奇HTTP服务器项目中的一个重要组成部分，它提供了一种高效...通过深入理解和熟练使用内存池，开发者可以更好地构建跨平台、高性能的系统。
编译 apr 1.6.5 需要的头文件 apr_escape_test_char.h
01-09
当我们遇到标题中提到的"编译 apr 1.6.5 需要的头文件 apr_escape_test_char.h"的情况，这意味着在使用Apache Portable Runtime (APR)库的版本1.6.5时，编译过程中缺少了一个特定的头文件。Apache Portable Runtime ...
JAVA CountDownLatch与thread-join()的区别解析
08-25
主要介绍了JAVA CountDownLatch与thread-join()的区别解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
APR分析-线程同步
angellove156的专栏
12-13 1750
在线程同步方面，Posix标准定义了3种同步模型，分别为互斥量、条件变量和读写锁。APR也“浅”封装了这3种模型，只是在“读写锁”一块儿还没有全部完成。 线程同步的源代码的位置在$(APR_HOME)/locks目录下，本篇blog着重分析unix子目录下的thread_mutex.c、thread_rwlock.c和thread_cond.c文件的内容，其相应头文件为(APR_HOME)/in
Tomcat中的线程池（APR和ThreadPool）
Josh_Persistence
11-10 456
一、容器简化了程序员自身的多线程编程。         各种Web容器，如Tomcat，Resion，Jetty等都有自己的线程池（可在配置文件中配置），所以在客户端进行请求调用的时候，程序员不用针对Client的每一次请求，都新建一个线程。而容器会自动分配线程池中的线程，提高访问速度。   二、Tomcat线程池实现： 1、使用APR的Pool技术，使用了JNI。 Tomcat从5....
android apr分析,APR分析-线程同步篇
weixin_39664962的博客
05-25 374
APR分析-线程同步篇在线程同步方面，Posix标准定义了3种同步模型，分别为互斥量、条件变量和读写锁。APR也“浅”封装了这3种模型，只是在“读写锁”一块儿还没有全部完成。线程同步的源代码的位置在$(APR_HOME)/locks目录下，本篇blog着重分析unix子目录下的thread_mutex.c、thread_rwlock.c和thread_cond.c文件的内容，其相应头文件为(APR...
Thread--Join方法
井底之蛙
03-29 910
join()函数是Thread类中定义的一个方法，join()的作用是让主线程等待子线程结束之后才能继续进行，简单的示例说明：// 主线程 public class Father extends Thread { public void run() { Son s = new Son(); s.start(); s.join();
线程Thread join 方法---优先执行
zqx198810的专栏
03-17 1169
join方法： 当A线程执行到了B线程的join()方法，A就会等待，等B线程都执行完，A才会执行。 join可以用来临时加入线程执行。 class Demo implements Runnable{ public void run(){ for(int x=0;x<70;x++){ system.out.println(Thread.currentThread().getName
Thread.join()方法原理分析
he_321的博客
02-23 758
如果现在有这样一个场景：在主线程中创建两个线程T1和T2，通过start启动线程后。我们想T1结束了再执行T2，等T1和T2都执行结束，才继续执行主线程，怎么能做到呢？ 其实很简单，通过join就可以实现： public class JoinDemo { private static int count = 0; public static void main(String[] a...
apache模块 多线程编程
zhangmiaoping23的专栏
12-08 1778
<br />用QT编写两个线程,然后在编写的Apache Module跑了一会儿,竟然程序崩溃了.看了资料,估计是和apr_pool_t有关.先把资料放在这里.<br />/** * apr tutorial sample code * http://dev.ariel-networks.com/apr/ */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #include <stdio.h> #include <stdlib.h>
APR（Apache Portable Run-time Librarie）介绍
herobox的专栏
05-04 7011
Apache Portable Run-time Librarie 在早期的Apache版本中，应用程序本身必须能够处理各种具体操作系统平台的细节，并针对不同的平台调用不同的处理函数。随着Apache的进一步开发，Apache组织决定将这些通用的函数独立出来并发展成为一个新的项目。这样，APR的开发就从Apache中独立出来，Apache仅仅是使用APR而已。 　　目前APR主要还是由
apr_thread_create: unable to create worker thread
最新发布
05-18
如果操作系统没有足够的资源来分配给这个线程，那么就会出现apr_thread_create: unable to create worker thread 的错误。 解决这个问题的方法包括： 1. 增加操作系统资源：如果你的程序需要创建大量的线程，那么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值