精华内容
下载资源
问答
  • Linux线程内存占用分析

    千次阅读 2014-08-11 22:39:11
    大概现象为,一个很简单的程序逻辑,开启了几个线程,程序本身并没有过多的申请内存,或者说根本没有申请内存,但是在实际运行起来后,通过PS命令和status 查看内存占用居然达到了40M,详细分析了smaps文件没有得到...

    在一次偶然的应程序开发过程中,发现一个很奇怪的问题。大概现象为,一个很简单的程序逻辑,开启了几个线程,程序本身并没有过多的申请内存,或者说根本没有申请内存,但是在实际运行起来后,通过PS命令和status 查看内存占用居然达到了40M,详细分析了smaps文件没有得到实际的分析结果。突然想到有可能是线程导致了进程的内存增加,于是便开始了测试代码的编写,测试代码如下:

    /* test_thread.c */
    #include <stdio.h>
    #include <unistd.h>
    #include <string.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <sys/types.h>
    //#include <limit.h>
    /* 测试第一个线程 */
    void * test_thread(void * pParam)
    {
        while(1)
        {
            sleep(1);
        }
        return (void*)0;
    }
    int main(int argc , char ** argv)
    {
        /* 启动一个线程 */
        pthread_t thread_id = 0;
        pthread_create(&thread_id,0,test_thread,0);
        while(1)
        {
            sleep(1);
        }
        return 0;
    }
    [oracle@localhost test_thread]$ gcc test_thread.c -lpthread
    [oracle@localhost test_thread]$ ls
    a.out  test_thread.c
    [oracle@localhost test_thread]$ ./a.out

    一个简单的多线程测试程序,该进程开启了两个线程,一个主线程,一个子线程。通过:

    [oracle@localhost test_thread]$ ps -aux | grep a.out
    Warning: bad syntax, perhaps a bogus '-'? See /usr/share/doc/procps-3.2.8/FAQ
    oracle   22725  0.0  0.0  12320   428 pts/0    Sl+  21:47   0:00 ./a.out
    oracle   22744  0.0  0.0   5952   748 pts/1    S+   21:47   0:00 grep a.out
    

    得到一个简单的多线程程序居然占了10MB内存之多,于是想到了多线程的线程栈空间问题,虽然多线程在运行时是共享内存空间的,但是各个线程之间的栈区还是是相对独立的,是不是在启动线程时,操作系统默认给子线程分配了过多的内存?二话不说,开始测试:

    void get_thread_stacksize()
    {
        pthread_attr_t pattr;
        int status = 0;
        size_t size = 0;
        //printf("default size:%d\n", size);
        status = pthread_attr_getstacksize(&pattr, &size);
        if(0 != status)
        {
            printf("pthread_attr_getstacksize err [%d]\n",status);
            return -1;
        }
        printf("current thread stack size:%d\n", size);
        return 0;
    }
    

    输出:

    [oracle@localhost test_thread]$ ./a.out 
    current thread stack size:10485760
    

    通过换算,刚好10MB,可见Linux默认情况下启动一个子线程需要分配10MB的线程栈空间,为了降低进程内存占用,就必须将该默认值修改,在Windows下该默认值一般为1MB,通过修改编译选项可以修改,在Linux中可以通过pthread_attr_getstacksize函数修改pthread_attr_t结构后,将pthread_attr_t结构传入pthread_create函数以修改线程默认栈大小。相关代码如下:

    #include <stdio.h>
    #include <unistd.h>
    #include <string.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <sys/types.h>
    //#include <limit.h>
    /* 测试第一个线程 */
    void * test_thread(void * pParam)
    {
        while(1)
        {
            sleep(1);
        }
        return (void*)0;
    }
    void get_thread_stacksize_for_attr(pthread_attr_t * p_pattr)
    {
        int status = 0;
        size_t size = 0;
        //printf("default size:%d\n", size);
        status = pthread_attr_getstacksize(p_pattr, &size);
        if(0 != status)
        {
            printf("pthread_attr_getstacksize err [%d]\n",status);
            return -1;
        }
        printf("current thread stack size:%d\n", size);
        return 0;
    }
    void get_thread_stacksize()
    {
        pthread_attr_t pattr;
        int status = 0;
        size_t size = 0;
        //printf("default size:%d\n", size);
        status = pthread_attr_getstacksize(&pattr, &size);
        if(0 != status)
        {
            printf("pthread_attr_getstacksize err [%d]\n",status);
            return -1;
        }
        printf("current thread stack size:%d\n", size);
        return 0;
    }
    void set_thread_stacksize(pthread_attr_t * p_pthread_attr_t,size_t size)
    {
        //pthread_attr_t pattr;
        int status = 0;
        //printf("default size:%d\n", size);
        status = pthread_attr_setstacksize(p_pthread_attr_t, size);
        if(0 != status)
        {
            printf("pthread_attr_getstacksize err [%d]\n",status);
            return -1;
        }
        printf("set thread stack size:%d\n", size);
        return 0;
    }
    int main(int argc , char ** argv)
    {
        /* 启动一个线程 */
        pthread_t thread_id = 0;
        pthread_attr_t pattr;
        pthread_attr_init(&pattr);
        /* 设置线程栈大小为1M */
        set_thread_stacksize(&pattr,1024*1024);
        //get_thread_stacksize();
        get_thread_stacksize_for_attr(&pattr);
        pthread_create(&thread_id,&pattr,test_thread,0);
        get_thread_stacksize();
        while(1)
        {
            sleep(1);
        }
        return 0;
    }
    [oracle@localhost test_thread]$ gcc *.c -lpthread
    test_thread.c: 在函数‘get_thread_stacksize_for_attr’中:
    test_thread.c:26: 警告:在无返回值的函数中,‘return’带返回值
    test_thread.c:29: 警告:在无返回值的函数中,‘return’带返回值
    test_thread.c: 在函数‘get_thread_stacksize’中:
    test_thread.c:41: 警告:在无返回值的函数中,‘return’带返回值
    test_thread.c:44: 警告:在无返回值的函数中,‘return’带返回值
    test_thread.c: 在函数‘set_thread_stacksize’中:
    test_thread.c:55: 警告:在无返回值的函数中,‘return’带返回值
    test_thread.c:58: 警告:在无返回值的函数中,‘return’带返回值
    [oracle@localhost test_thread]$ 
    [oracle@localhost test_thread]$ 
    [oracle@localhost test_thread]$ 
    [oracle@localhost test_thread]$ 
    [oracle@localhost test_thread]$ ./a.out 
    set thread stack size:1048576
    current thread stack size:1048576
    current thread stack size:10485760
    
    
    oracle    3631  0.0  0.0   5952   748 pts/1    S+   22:26   0:00 grep ./a.out
    [oracle@localhost test_thread]$ ps -aux | grep ./a.out
    Warning: bad syntax, perhaps a bogus '-'? See /usr/share/doc/procps-3.2.8/FAQ
    oracle    3664  0.0  0.0   3108   508 pts/0    Sl+  22:27   0:00 ./a.out
    oracle    3669  0.0  0.0   5952   776 pts/1    S+   22:27   0:00 grep ./a.out
    

    通过测试,修改线程堆栈大小后有效的更改了启动线程时对内存空间的要求。

    扩展:

    1、  获取Linux默认线程栈大小

    Ulimite –s

    2、  修改Linux默认线程栈大小

    Ulimite –s value


    展开全文
  • 最近查系统的内存泄露问题时,发现VIRT内存涨的特别厉害,

    最近查项目linux工程的内存泄露问题时,发现VIRT内存涨的特别厉害,开20线运行12个多小时,内存涨了70多个G,吓死个人,最后通过查阅资料和博客,发现是下面的情况导致的。


    情况说明:

     main

     {

                     for(i=0;i<num;i++)

                       {

                                pthread_attr_t threadAttr;
                                 pthread_attr_init(&threadAttr);
                                 // Set the stack size of the thread
                                 pthread_attr_setstacksize(&threadAttr, 120*1024);
                               //The default stack size is 2M !
                              pthread_create(&(Threadhandle[i]), NULL, InstanceThreadProc, intancePara+i);
                              pthread_attr_destroy(&threadAttr);     

                       } 

                 ........

                   for(i=0;i<nThread;i++)
               {
                      printf("thread %d - ok\n",i);
                      pthread_join(Threadhandle[i], NULL);
               }

      }

    VOID InstanceThreadProc(PVOID pvoid)

    {

         while(1)

           {

                 sem_init(&(pollpara.hStop),0,0);

                sem_init(&(pollpara.pollStoped),0,0);  

                pthread_attr_t threadAttr;

                 pthread_attr_init(&threadAttr);
                 pthread_attr_setstacksize(&threadAttr, 120*1024);
                 pthread_create(&Threadhandle, NULL, PollingThread,&pollpara);
                pthread_attr_destroy(&threadAttr);

          }

       ......

            sem_wait(&pollpara.hStop);

    }


    VOID PollingThread (PVOID pvoid)

    {

             //其他操作和处理

           。。。。。

            sem_post(&(pPara->hStop));

    }


    出问题的地方:

    1. InstanceThreadProc线程中不断的创建线程PollingThread 

    2.线程同步机制sem只是负责同步或通知,并不负责线程资源的释放

    也即是说即使线程InstanceThreadProc能够等待(使用sem)pollingThread线程正确退出,但是由于Linux下,使用pthread_create建立的线程默认是joinable属性的,如果不调用pthread_join等待该线程结束的话,系统为pollingThread开辟的内存资源无法回收,导致内存泄露。


    修改方案

    1.在InstanceThreadProc中使用pthread_join等待线程结束

    2.在创建线程pollingThread的时候,将其属性设置为PTHREAD_CREATE_DETACHED,这样线程结束后,系统会自动回线程资源,但是此种情况下,不能使用pthread_join来等待线程结束

    3.在线程pollingThread函数的开头,调用pthread_detach(pthread_self()),表示在线程结束后会自行释放 自身所占用的资源。


    总结

        Linux中,默认情况下是在一个线程被创建后,必须使用pthread_join函数对创建的线程进行资源回收,但是可以设置Threads attributes来设置当一个线程结束时,直接回收此线程所占用的系统资源

      Linux下,使用pthread_create建立的线程默认是joinable属性的,如果不调用pthread_join等待该线程结束,那么即便该线程调用pthread_exit使线程函数退出后, 线程本身的资源仍不会释放,这样线程资源就不会释放,导致内存泄露出现。






    展开全文
  • 事情开始于一段内存问题,通过gperf工具抓取进程运行过程中的内存占用情况。 分析结果时发现一个有趣的事情,top看到的实际物理内存只有几兆,但是pprof统计的内存信息缺达到了几个G。 很明显是创建线程时产生的...

    问题描述

    事情开始于一段内存问题,通过gperf工具抓取进程运行过程中的内存占用情况。
    分析结果时发现一个有趣的事情,top看到的实际物理内存只有几兆,但是pprof统计的内存信息却达到了几个G(其实这个问题用gperf heap profiler的选项也能很好的验证想法,但是还是想探索一番)。
    在这里插入图片描述
    很明显是创建线程时产生的内存分配,且最终的分配函数是__pthread_create_2_1,这是当前版本glibc创建线程时的实现函数,且在该函数内进行线程空间的分配。

    查看进程代码,发现确实有大量的线程创建,我们知道线程是有自己独立的栈空间,top的 RES统计的是当前进程占用物理内存的情况,也就是当用户进程想要申请物理内存的时候会发出缺页异常,进程切换到内核态,由内核调用对应的系统调用取一部分物理内存加入页表交给用户态进程。这个时候,使用的物理内存的大小才会被计算到RES之中。

    回到top数据和pprof抓取的内存数据对不上的问题,难道单独线程的创建并不会占用物理内存?

    到现在为止可以梳理出以下几个问题:

    1. 线程的创建消耗的内存在哪里? (猜测可能在栈上,因为top的VIRT确实很大)
    2. 消耗的内存大小 是如何判断的?(目前还不太清楚,不过以上进程代码是创建了800个线程,算下来平均每个线程的大小是10M了)

    问题分析

    1. 为了单独聚焦线程创建时的内存分配问题,编写如下的简单测试代码,创建800个线程:

      #include <cstdio>
      #include <cstdlib>
      #include <thread>
      
      void f(long id) {
        fprintf(stdout, "create thread %ld\n",id);
        sleep(10000);
                    
      }
      
      int main()
      {
         long thread_num = 800;                    // client thread num
         std::vector<std::thread> v;
         for (long id = 0;id < thread_num; ++id ) {
      		std::thread t(f,id); 
      		t.detach();
      		fprintf(stdout, "exit ...\n");
          }
      	printf("\n");
      	sleep(4000);  
      	return 0;
      }
      

      单纯的创建线程,并不做其他的内存分配操作。

    2. 为了抓取该进程的内存分配过程,我们加入gperf工具来运行查看。

      #当前shell的环境变量中加入tcmalloc动态库的路径
      #如果没有tcmalloc,则yum install gperftools即可
      env LD_PRELOAD="/usr/lib/libtcmalloc.so"
      
      #编译加入链接tcmalloc的选项
      g++ -std=c++11 test.cpp -pthread -ltcmalloc
      
      #使用会生成heap profile的方式启动进程
      #开启只监控mmap,mremap,sbrk的系统调用分配内存的方式,并且ctrl+c停止运行时生成heap文件
      HEAPPROFILESIGNAL=2  HEAP_PROFILE_ONLY_MMAP=true HEAP_PROFILE_INUSE_INTERVAL=1024 HEAPPROFILE=./thread ./a.out
      
    3. 进程运行的过程中我们使用pmap查看进程内存空间的分配情况
      pmap -X PID
      输出信息如下
      在这里插入图片描述
      其中:
      address为进程的虚拟地址
      size为当前字段分配的虚拟内存的大小,单位是KB
      Rss为占用的物理内存的大小
      Mapping为内存所处的区域

    统计了一下size:10240KB 的区域刚好是800个,显然该区域为线程空间。所处的进程内存区域也不在heap上,占用的物理内存大小大小也就是一个指针的大小,8B
    使用pmap PID再次查看发现线程的空间都分布在anno区域上,即使用的匿名页的方式
    在这里插入图片描述

    匿名页的描述信息如下:

    The amount of anonymous memory is reported for each mapping. Anonymous memory shared with other address spaces is not included, unless the -a option is specified.
    Anonymous memory is reported for the process heap, stack, for ‘copy on write’ pages with mappings mapped with MAP_PRIVATE.

    即匿名页是使用mmap方式分配的,且会将使用的内存叶标记为MAP_PRIVATE,即仅为进程用户空间独立使用。

    针对问题1 的猜测:

    到现在为止我们通过工具发现了线程的内存分配貌似是通过mmap,使用匿名页的方式分配出来的,因为匿名页能够和其他进程共享内存空间,所以不会被计入当前进程的物理内存区域。
    关于进程的内存分布可以参考进程内存分布,匿名页是在堆区域和栈区域之间的一部分内存区域,pmap的输出我们也能看出来mmapping的那一列。

    针对问题2 的猜测:

    那为什么会占用10M的虚拟内存呢(size那一列),显然也很好理解了。因为线程是独享自己的栈空间的,所以需要为每个线程开辟属于自己的函数栈空间来保存函数栈帧和局部变量。
    ulimit -a能够看到stack size 那一行是属于当前系统默认的进程栈空间的大小。

    这里可以通过ulimit -s 2048 将系统的默认分配的栈的大小设置为2M,再次运行程序会发现线程的虚拟内存占用变为了2M

    是不是很有趣。
    到了这里,我们仅仅是使用工具进行了线程内存的占用分析,但问题并没有追到底层。

    原理追踪

    我们上面使用了gperf的heap proflie运行了程序,此时我们ctrl+c终端进程之后会在当前目录下生成很多个.heap文件,使用pprof 的svg选项将文件内容导出
    pprof --svg a.out thread.0001.heap > thread.svg
    将导出的thread.svg放入浏览器中可以看到线程内存占用的一个calltrace,如下(如果程序中链入了glibc以及内核的静态库,估计calltrace会庞大很多):
    在这里插入图片描述
    也就是线程创建时的栈空间的分配最终是由函数__pthread_create_2_1分配的。

    PS:这里的calltrace 仅仅包括mmap,mremap,sbrk的分配,因为我们在进程运行的时候指定了HEAP_PROFILE_ONLY_MMAP=true 选项,如果各位仅仅想要确认malloc,calloc,realloc等在堆上分配的内存大小可以去掉该选项来运行进程。
    输出svg的时候增加pprof的--ignore选项来忽略mmap,sbrk的分配内存,这样的calltrace就没有他们的内存占用了,仅包括堆上的内存占用
    pprof --ignore='DoAllocWithArena|SbrkSysAllocator::Alloc|MmapSysAllocator::Alloc' --svg a.out thread.0001.heap > thread.svg

    查看glibc的线程创建源码pthread_create.c
    函数__pthread_create_2_1 调用ALLOCATE_STACK为线程的数据结构pd分配内存空间。

    versioned_symbol (libpthread, __pthread_create_2_1, pthread_create, GLIBC_2_1)
    
    int
    __pthread_create_2_1 (newthread, attr, start_routine, arg)
         pthread_t *newthread;
         const pthread_attr_t *attr;
         void *(*start_routine) (void *);
         void *arg;
    {
    	......
    	struct pthread *pd = NULL;
    	int err = ALLOCATE_STACK (iattr, &pd);
    	if (__builtin_expect (err != 0, 0)
    	......
    }
    

    ALLOCATE_STACK函数实现入下allocatestack.c
    分配的空间大小会优先从用户设置的pthread_attr属性 attr.stacksize中获取,如果用户进程没有设置stacksize,就会获取系统默认的stacksize的大小。

    接下来会调用get_cached_stack函数来获取栈上面可以获得的空间大小size以及所处的虚拟内存空间的地址mem。

    最后通过mmap将当前线程所需要的内存叶标记为MAP_PRIVATE和MAP_ANONYMOUS表示当前内存区域仅属于用户进程且被用户进程共享。

    详细实现如下:

    static int
    allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
    		ALLOCATE_STACK_PARMS)
    {
    	......
      /* Get the stack size from the attribute if it is set.  Otherwise we
         use the default we determined at start time.  */
      size = attr->stacksize ?: __default_stacksize;
     	 ......
    
       void *mem;
       ......
       
       /* Try to get a stack from the cache.  */
       reqsize = size;
       pd = get_cached_stack (&size, &mem);
       if (pd == NULL)
    	{
    	  /* To avoid aliasing effects on a larger scale than pages we
    	     adjust the allocated stack size if necessary.  This way
    	     allocations directly following each other will not have
    	     aliasing problems.  */
    	#if MULTI_PAGE_ALIASING != 0
    	  if ((size % MULTI_PAGE_ALIASING) == 0)
    	    size += pagesize_m1 + 1;
    	#endif
    	  /*mmap分配物理内存,并进行内存区域的标记*/
    	  mem = mmap (NULL, size, prot,
    		      MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
    
    	  if (__builtin_expect (mem == MAP_FAILED, 0))
    	    {
    	      if (errno == ENOMEM)
    		__set_errno (EAGAIN);
    
    	       return errno;
    	    }
    

    总结

    glibc用户态的调用到最后仍然还是内核态进行实际的物理操作。
    至此,关于线程创建时的内存分配追踪就到这里了。我们会发现操作系统的博大精深和环环相扣,使用一个个工具验证自己的猜测, 再从原理发掘前人的设计,这样就会对整个链路有了一个更加深刻的理解。

    至于更加底层的内核实现,如何将物理内存与用户进程进行隔离且互不影响,这又是一段庞大复杂的设计链路。有趣的事情很多,慢慢来~

    展开全文
  • 特别是一些老设备(512MB内存),之前的一台终端设备因为内存占用过高,出现了运行出错,进程管理的APP直接杀死了占用最高的媒体APP,导致视频输出出现异常。 于是进探索了内存优化之路。在确保长时间运行内存不会...

    嵌入式开发的内存无疑是非常吃紧的。特别是一些老设备,之前的一台终端设备因为内存占用过高,出现了运行出错,进程管理的APP直接杀死了占用最高的媒体APP,导致视频输出出现异常。先优化一下VSZ好了。
    于是进探索了内存优化之路。在确保长时间运行内存不会增加(没有内存泄漏)后,首先查看 /proc 下的进程 内存占用的smap 信息:

    cat /proc/<pid>/smaps|grep -v ' 0 kB'
    

    查看进程申请的内存详情
    通过观察不难发现大量的内存占用都在栈上。由于这个APP是一个多线程进程,一个线程就有一个栈,导致了进程申请的内存大量被用于线程栈的申请上,每个栈8MB,仅10个线程就占用了100MB的虚拟内存空间。
    stack mem
    一个进程占用99MB内存,11个线程栈的内存占了88MB。那么方向就很明确了。减少栈的大小即可。
    首先想到的是,直接进行全局的配置系统默认栈得大小,因为目前Linux程序的线程使用的都是默认的参数,即采用系统默认的栈大小进行开辟线程的栈。使用ulimit -s 指令在启动脚本加入:

    ulimit -s 1024
    

    以上就将系统默认栈设置为1024KB,单位是KB。启动系统,不巧的是,有些APP运行出现了异常,猜测界面APP使用了大量的变量,导致栈的溢出,APP直接就退出了。缩小系统栈还是有一定的风险,而且不知会不会引入其他的问题。
    想着既然Linux系统一般都是使用pthread启动线程,而且子线程一般变量较少,不需要很大的栈空间,那么我们可以通过pthread_create的pthread_attr_t进行参数的设定设定进程生成的线程栈,达到缩小进程内存占用的目的。
    将佘艳的线程生成

    int thread::startThread(callable *c) {
    
    	int const res = pthread_create(&handle_, 0, &posix_thread_proxy, static_cast<void*>(c));
    	if (res != 0) {
    		delete c;
    		return -1;
    	}
    
    	return 0;
    }
    

    改为这样创建线程(这里的stacksize的单位是字节)

    int thread::startThread(callable *c) {
    
    	pthread_attr_t thread_attr;
    	pthread_attr_init(&thread_attr);
    	pthread_attr_setstacksize(&thread_attr, 1024*1024); ///< 1MB
    	int const res = pthread_create(&handle_, &thread_attr, &posix_thread_proxy, static_cast<void*>(c));
    	if (res != 0) {
    		delete c;
    		return -1;
    	}
    	pthread_attr_destroy(&thread_attr);
    
    	return 0;
    }
    

    即可将原来的8MB栈大小改为1MB,效果显著。

    top指令查看 左边为修改前,右侧为修改后
    top
    ps -o pid,comm,rss,vsz 指令查看 左边为修改前,右侧为修改后
    ps
    可以看到线程多的APP占用基本缩小了一半多。

    展开全文
  • 目录 Linux下多线程pthread内存泄露 Linux下多线程pthread内存泄露 目标文件:/proc//maps 若其中出现了大量的8K左右的内存碎片,则说明出现了内存泄露。同理,如果相应pid进程的maps文件中出现了很多内存碎片,也...
  • linux线程内存开销

    千次阅读 2018-12-10 17:21:07
    2.跟版本有关,是否有 glibc 的 malloc per thread arenas 特性,有了这个特性,设置不好,一个新线程要增加至少64MB的内存,  这个主要是用来解决,线程申请堆内存时,互相竞争的问题。每个线程优先在这个空间内...
  • linux下一个线程占用多少内存

    万次阅读 2011-07-06 09:34:25
    群里讨论出mysql的问题,因为mysql是一个连接建立一个线程的,这就涉及到mysql可以建立多少...无论是windwos 还是linux ,每个线程都有自己独立的stack,每个stack 都占用一定的空间。windwos 默认的是1M,这个在exe中
  • Linux 查看线程占用情况

    千次阅读 2016-01-08 14:14:50
    查看线程资源占用情况 top -H -p pid 找到对应的pid,转换成16进制 printf 0x%x pid 然后jstack pid > 文件 在文件中查找16进制pid
  • Linux下创建一个线程占用多少内存

    千次阅读 2018-09-08 12:57:34
    在前面的博客进程分配资源中,我们了解到,在32位平台下,系统会给一个进程分配4G的虚拟内存供进程使用。 因此,我们知道,一个进程被创建时将被分配有4G的虚拟内存。事实上,并不是每次都会用完这4G内存的,下面的...
  • 1、使用top命令 ,查询java进程 比如选择86184这个进程 2、用 top -H -p 86184 ,查询该...4、比如,观察到86344这个线程占用cpu 大, 将十进制的86344 转换成16进制 15148 (十进制转为其他进制 : echo "obas...
  • 1、用命令top查看java进程的内存和cpu占用情况。2、jmap -histo pid查询指定java进程的所有对象使用内存情况。3、ps -mp pid -o THREAD,tid,time 查询所有线程列表4、将需要的线程ID转换为16进制格式:printf "...
  • LinuxLinux线程技术

    万次阅读 2018-09-05 15:57:23
    Linux线程概念 线程的概念 线程是计算机科学中的一个术语,是指运行中的程序的调度单位。一个线程指的是进程中一个单一顺序的控制流,也称为轻量进程。它是系统独立调度和分配的基本单位。同一进程中的多个线程...
  • linux 进程占用内存查询

    万次阅读 2014-04-15 17:58:51
    作者: 黄永兵/译 出处:51CTO.com 阅读提示:本文是为那些经常疑惑的人准备的,“为什么一个简单的KDE文本编辑器要占用25M内存?”导致大多数人认为许多Linux应用程序,特别是KDE或GNOME程序都象ps报告一样臃肿......
  • 所以开撸,发现当我在调试一个线程池时,发现使用了一两个小时后,虚拟内存占用得非常高。然后我开始分析,一开始我先写了一个不带调整线程的线程池,发现线程池开启几个小时后,虚拟内存都是很稳定,基本也就正常的...
  • Linux线程

    千次阅读 2019-04-23 15:43:32
    Linux线程_01线程介绍和常用系统调用1.Linux线程1.1进程回顾1.2程序并发的时空开销1.3线程的的特点2.POSIX线程常用系统调用2.1线程创建与回收2.2线程取消2.3线程函数退出相关2.4获取线程id 1.Linux线程 如果说在操作...
  • 就这么写了,参数2没有设置线程结束后自动detach,并且没有使用pthread_join或pthread_detach释放执行结束后线程的空间!  Linux man page 里有已经说明了这个问题:  When a joinable thread terminates, i
  • LINUX线程

    2019-08-15 01:10:14
    LINUX线程 线程的概念 线程(英语:thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条...
  • Linux 线程CPU占用率过高定位分析

    千次阅读 2020-07-21 23:01:55
    Linux开发中经常会与多线程打交道,所以多线程开发与调试就很重要 下边说下Linux调试过程中CPU占用率过高的情况怎么调试 CPU占用过高,模拟CPU占用过高的情况 先上一段代码: #include <iostream> #...
  • linux 查看进程占用内存

    万次阅读 2012-04-03 11:01:13
    1.top  top -b -n 1 |grep opera|awk '{print "cpu:"$9"%","mem:"$10"%"}'  cpu:0.0% mem:26.4% ...RSS-------------进程实际占用物理内存大小; VSZ--------------任务虚拟地址空间的大小 3./proc/pid/status [r
  • linux 进程线程小程序

    2018-06-06 14:17:07
    包含线程,进程,信号量,管道,共享内存等部分内容,
  • linux线程pthread

    万次阅读 2010-10-04 11:58:00
    1.Linux线程的发展  早在LINUX2.2内核中。并不存在真正意义上的线程,当时Linux中常用的线程pthread实际上是通过进程来模拟的,也就是同过fork来创建“轻”进程,并且这种轻进程的线程也有个数的限制:...
  • Linux线程

    千次阅读 2009-01-08 16:14:00
    一:Linux线程编程: 线程(thread)技术早在60年代就被提出,但真正应用多线程到操作系统中去,是在80年代中期,solaris是这方面的佼佼者。传统的Unix也支持线程的概念,但是在一个进程(process)中只允许有一...
  • Linux线程编程与线程间通信机制

    千次阅读 2016-01-26 17:04:44
    Linux中多线程编程技术被广泛使用,这主要是因为多线程...目前线程间通信的用的比较多的主要技术有消息队列、共享内存。本文就来讲讲linux中多线程编程的实现,以及利用消息队列进行线程间通信。   一、线程的创建
  • Linux进程查看命令 PS命令 1.不带参数的ps使用 2.显示所有的当前进程 ps –ax -a 代表 all。同时加上x参数会显示没有控制终端的进程。 ps -ax | less 可以结合less命令和管道来使用以方便查看。 3.通过cpu和...
  • t 甚或几 p 的数据的数据库系统,到手机上的一个有良好用户响应能力的 app,为了充分利用每个 CPU 内核,都会想到是否可以使用多线程技术。这里所说的“充分利用”包含了两个层面的意思,一
  • 设备还有8M剩余内存可在一台跑2.6内核的嵌入式linux设备上(可视对讲门口机),大概有十几个进程,其中自己的应用程序占用1个hicore进程,里面大概跑了四五十个线程,设备有gui界面、可以进行sip对讲、人脸识别等。...
  • Linux线程编程

    千次阅读 2012-08-17 14:08:09
    一:Linux线程编程:    线程(thread)技术早在60年代就被提出,但真正应用多线程到操作系统中去,是在80年代中期,solaris是这方面的佼佼者。传统的Unix也支持线程的概念,但是在一个进程(process)中只...
  • linux线程编程

    千次阅读 2011-09-28 19:42:01
    Linux 平台上的多线程程序开发相对应其他平台(比如 Windows)的多线程 API 有一些细微和隐晦的差别。不注意这些 Linux 上的一些开发陷阱,常常会导致程序问题不穷,死锁不断。本文中我们从 5 个方面总结出 Linux 多...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 131,235
精华内容 52,494
关键字:

linux查询线程占用内存

linux 订阅