精华内容
下载资源
问答
  • 内存管理:程序是如何被优雅的装载到内存中的

    千次阅读 多人点赞 2021-11-04 09:26:35
    内存作为计算机中一项比较重要的资源,它的主要作用就是解决CPU和磁盘之间速度的鸿沟,但是由于内存条是需要插入到主板上的,因此对于一台计算机来说,由于物理限制,它的内存不可能无限大的。我们知道我们写的代码...

    内存作为计算机中一项比较重要的资源,它的主要作用就是解决CPU和磁盘之间速度的鸿沟,但是由于内存条是需要插入到主板上的,因此对于一台计算机来说,由于物理限制,它的内存不可能无限大的。我们知道我们写的代码最终是要从磁盘被加载到内存中的,然后再被CPU执行,不知道你有没有想过,为什么一些大型游戏大到10几G,却可以在只有8G内存的电脑上运行?甚至在玩游戏期间,我们还可以聊微信、听音乐...,这么多进程看着同时在运行,它们在内存中是如何被管理的?带着这些疑问我们来看看计算系统内存管理那些事。

    内存的交换技术

    如果我们的内存可以无限大,那么我们担忧的问题就不会存在,但是实际情况是往往我们的机器上会同时运行多个进程,这些进程小到需要几十兆内存,大到可能需要上百兆内存,当许许多多这些进程想要同时加载到内存的时候是不可能的,但是从我们用户的角度来看,似乎这些进程确实都在运行呀,这是怎么回事?

    这就引入要说的交换技术了,从字面的意思来看,我想你应该猜到了,它会把某个内存中的进程交换出去。当我们的进程空闲的时候,其他的进程又需要被运行,然而很不幸,此时没有足够的内存空间了,这时候怎么办呢?似乎刚刚那个空闲的进程有种占着茅坑不拉屎的感觉,于是可以把这个空闲的进程从内存中交换到磁盘上去,这时候就会空出多余的空间来让这个新的进程运行,当这个换出去的空闲进程又需要被运行的时候,那么它就会被再次交换进内存中。通过这种技术,可以让有限的内存空间运行更多的进程,进程之间不停来回交换,看着好像都可以运行。 

     如图所示,一开始进程A被换入内存中,所幸还剩余的内存空间比较多,然后进程B也被换入内存中,但是剩余的空间比较少了,这时候进程C想要被换入到内存中,但是发现空间不够了,这时候会把已经运行一段时间的进程A换到磁盘中去,然后调入进程C。 

    内存碎片

    通过这种交换技术,交替的换入和换出进程可以达到小内存可以运行更多的进程,但是这似乎也产生了一些问题,不知道你发现了没有,在进程C换入进来之后,在进程B和进程C之间有段较小的内存空间,并且进程B之上也有段较小的内存空间,说实话,这些小空间可能永远没法装载对应大小的程序,那么它们就浪费了,在某些情况下,可能会产生更多这种内存碎片。

     如果想要节约内存,那么就得用到内存紧凑的技术了,即把所有的进程都向下移动,这样所有的碎片就会连接在一起变成一段更大的连续内存空间了。 

     但是这个移动的开销基本和当前内存中的活跃进程成正比,据统计,一台16G内存的计算机可以每8ns复制8个字节,它紧凑全部的内存大概需要16s,所以通常不会进行紧凑这个操作,因为它耗费的CPU时间还是比较大的。

    动态增长

    其实上面说的进程装载算是比较理想的了,正常来说,一个进程被创建或者被换入的时候,它占用多大的空间就分配多大的内存,但是如果我们的进程需要的空间是动态增长的,那就麻烦了,比如我们的程序在运行期间的for循环可能会利用到某个临时变量来存放目标数据(例如以下变量a,随着程序的运行是会越来越大的):

    var a []int64
    for i:= 0;i <= 1000000;i++{
      if i%2 == 0{
       a = append(a,i) //a是不断增大的
      }
    }
    

    当需要增长的时候:

    1. 如果进程的邻居是空闲区那还好,可以把该空闲区分配给进程
    2. 如果进程的邻居是另一个进程,那么解决的办法只能把增长的进程移动到一个更大的空闲内存中,但是万一没有更大的内存空间,那么就要触发换出,把一个或者多个进程换出去来提供更多的内存空间,很明显这个开销不小。

    为了解决进程空间动态增长的问题,我们可以提前多给一些空间,比如进程本身需要10M,我们多给2M,这样如果进程发生增长的时候,可以利用这2M空间,当然前提是这2M空间够用,如果不够用还是得触发同样的移动、换出逻辑。

    空闲的内存如何管理

    前面我们说到内存的交换技术,交换技术的目的是腾出空闲内存来,那么我们是如何知道一块内存是被使用了,还是空闲的?因此需要一套机制来区分出空闲内存和已使用内存,一般操作系统对内存管理的方式有两种:位图法链表法

    位图法

    先说位图法,没错,位图法采用比特位的方式来管理我们的内存,每块内存都有位置,我们用一个比特位来表示:

    1. 如果某块内存被使用了,那么比特位为1
    2. 如果某块内存是空闲的,那么比特位为0

    这里的某块内存具体是多大得看操作系统是如何管理的,它可能是一个字节、几个字节甚至几千个字节,但是这些不是重点,重点是我们要知道内存被这样分割了。

     位图法的优点就是清晰明确,某个内存块的状态可以通过位图快速的知道,因为它的时间复杂度是O(1),当然它的缺点也很明显,就是需要占用太多的空间,尤其是管理的内存块越小的时候。更糟糕的是,进程分配的空间不一定是内存块的整数倍,那么最后一个内存块中一定是有浪费的。

    如图,进程A和进程B都占用的最后一个内存块的一部分,那么对于最后一个内存块,它的另一部分一定是浪费的。

    链表法

    相比位图法,链表法对空间的利用更加合理,我相信你应该已经猜到了,链表法简单理解就是把使用的和空闲的内存用链表的方式连接起来,那么对于每个链表的元素节点来说,他应该具备以下特点:

    1. 应该知道每个节点是空闲的还是被使用的
    2. 每个节点都应该知道当前节点的内存的开始地址和结束地址

    针对这些特点,最终内存对应的链表节点大概是这样的:

     p代表这个节点对应的内存空间是被使用的,H代表这个节点对应的内存空间是空闲的,start代表这块内存空间的开始地址,length代表的是这块内存的长度,最后还有指向邻居节点的pre和next指针

    因此对于一个进程来说,它与邻居的组合有四种:

    1. 它的前后节点都不是空闲的
    2. 它的前一个节点是空闲的,它的后一个节点也不是空闲的
    3. 它的前一个节点不是空闲的,它的后一个节点是空闲的
    4. 它的前后节点都是空闲的

    当一个内存节点被换出或者说进程结束后,那么它对应的内存就是空闲的,此时如果它的邻居也是空闲的,就会发生合并,即两块空闲的内存块合并成一个大的空闲内存块。

    ok,通过链表的方式把我们的内存给管理起来了,接下来就是当创建一个进程或者从磁盘换入一个进程的时候,如何从链表中找到一块合适的内存空间?

    首次适应算法

    其实想要找到空闲内存空间最简单的办法就是顺着链表找到第一个满足需要内存大小的节点,如果找到的第一个空闲内存块和我们需要的内存空间是一样大小的,那么就直接利用,但是这太理想了,现实情况大部分可能是找到的第一个目标内存块要比我们的需要的内存空间要大一些,这时候呢,会把这个空闲内存空间分成两块,一块正好使用,一块继续充当空闲内存块。

     一个需要3M内存的进程,会把4M的空间拆分成3M和1M。

    下次适配算法

    和首次适应算法很相似,在找到目标内存块后,会记录下位置,这样下次需要再次查找内存块的时候,会从这个位置开始找,而不用从链表的头节点开始寻找,这个算法存在的问题就是,如果标记的位置之前有合适的内存块,那么就会被跳过。

     一个需要2M内存的进程,在5这个位置找到了合适的空间,下次如果需要这1M的内存会从5这个位置开始,然后会在7这个位置找到合适的空间,但是会跳过1这个位置。

    最佳适配算法

    相比首次适应算法,最佳适配算法的区别就是:不是找到第一个合适的内存块就停止,而是会继续向后找,并且每次都可能要检索到链表的尾部,因为它要找到最合适那个内存块,什么是最合适的内存块呢?如果刚好大小一致,则一定是最合适的,如果没有大小一致的,那么能容得下进程的那个最小的内存块就是最合适的,可以看出最佳适配算法的平均检索时间相对是要慢的,同时可能会造成很多小的碎片。

     假设现在进程需要2M的内存,那么最佳适配算法会在检索到3号位置(3M)后,继续向后检索,最终会选择5号位置的空闲内存块。

    最差适配算法

    我们知道最佳适配算法中最佳的意思是找到一个最贴近真实大小的空闲内存块,但是这会造成很多细小的碎片,这些细小的碎片一般情况下,如果没有进行内存紧凑,那么大概率是浪费的,为了避免这种情况,就出现了这个最差适配算法,这个算法它和最佳适配算法是反着来的,它每次尝试分配最大的可用空闲区,因为这样的话,理论上剩余的空闲区也是比较大的,内存碎片不会那么小,还能得到重复利用。

     一个需要1.5M的进程,在最差适配算法情况下,不会选择3号(2M)内存空闲块,而是会选择更大的5号(3M)内存空闲块。

    快速适配算法

    上面的几种算法都有一个共同的特点:空闲内存块和已使用内存块是共用的一个链表,这会有什么问题呢?正常来说,我要查找一个空闲块,我并不需要检索已经被使用的内存块,所以如果能把已使用的和未使用的分开,然后用两个链表分别维护,那么上面的算法无论哪种,速度都将得到提升,并且节点也不需要P和M来标记状态了。但是分开也有缺点,如果进程终止或者被换出,那么对应的内存块需要从已使用的链表中删掉然后加入到未使用的链表中,这个开销是要稍微大点的。当然对于未使用的链表如果是排序的,那么首次适应算法和最佳适应算法是一样快的。

    快速适配算法就是利用了这个特点,这个算法会为那些常用大小的空闲块维护单独的链表,比如有4K的空闲链表、8K的空闲链表...,如果要分配一个7K的内存空间,那么既可以选择两个4K的,也可以选择一个8K的。

     它的优点很明显,在查找一个指定大小的空闲区会很快速,但是一个进程终止或被换出时,会寻找它的相邻块查看是否可以合并,这个过程相对较慢,如果不合并的话,那么同样也会产生很多的小空闲区,它们可能无法被利用,造成浪费。

    虚拟内存:小内存运行大程序

    可能你看到小内存运行大程序比较诧异,因为上面不是说到了吗?只要把空闲的进程换出去,把需要运行的进程再换进来不就行了吗?内存交换技术似乎解决了,这里需要注意的是,首先内存交换技术在空间不够的情况下需要把进程换出到磁盘上,然后从磁盘上换入新进程,看到磁盘你可能明白了,很慢。其次,你发现没,换入换出的是整个进程,我们知道进程也是由一块一块代码组成的,也就是许许多多的机器指令,对于内存交换技术来说,一个进程下的所有指令要么全部进内存,要么全部不进内存。看到这里你可能觉得这不是正常吗?好的,别急,我们接着往下看。

    后来出现了更牛逼的技术:虚拟内存。它的基本思想就是,每个程序拥有自己的地址空间,尤其注意后面的自己的地址空间,然后这个空间可以被分割成多个块,每一个块我们称之为(page)或者叫页面,对于这些页来说,它们的地址是连续的,同时它们的地址是虚拟的,并不是真正的物理内存地址,那怎么办?程序运行需要读到真正的物理内存地址,别跟我玩虚的,这就需要一套映射机制,然后MMU出现了,MMU全称叫做:Memory Managment Unit,即内存管理单元,正常来说,CPU读某个内存地址数据的时候,会把对应的地址发到内存总线上,但是在虚拟内存的情况下,直接发到内存总线上肯定是找不到对应的内存地址的,这时候CPU会把虚拟地址告诉MMU,让MMU帮我们找到对应的内存地址,没错,MMU就是一个地址转换的中转站。

    程序地址分页的好处是:

    1. 对于程序来说,不需要像内存交换那样把所有的指令都加载到内存中才能运行,可以单独运行某一页的指令
    2. 当进程的某一页不在内存中的时候,CPU会在这个页加载到内存的过程中去执行其他的进程。

    当然虚拟内存会分页,那么对应的物理内存其实也会分页,只不过物理内存对应的单元我们叫页框。页面和页框通常是一样大的。我们来看个例子,假设此时页面和页框的大小都是4K,那么对于64K的虚拟地址空间可以得到64/4=16个虚拟页面,而对于32K的物理地址空间可以得到32/4=8个页框,很明显此时的页框是不够的,总有些虚拟页面找不到对应的页框。

    我们先来看看虚拟地址为20500对应物理地址如何被找到的:

    1. 首先虚拟地址20500对应5号页面(20480-24575)
    2. 5号页面的起始地址20480向后查找20个字节,就是虚拟地址的位置
    3. 5号页面对应3号物理页框
    4. 3号物理页框的起始地址是12288,12288+20=12308,即12308就是我们实际的目标物理地址。

    但是对于虚拟地址而言,图中还有红色的区域,上面我们也说到了,总有些虚拟地址没有对应的页框,也就是这部分虚拟地址是没有对应的物理地址,当程序访问到一个未被映射的虚拟地址(红色区域)的时候,那么就会发生缺页中断,然后操作系统会找到一个最近很少使用的页框把它的内容换到磁盘上去,再把刚刚发生缺页中断的页面从磁盘读到刚刚回收的页框中去,最后修改虚拟地址到页框的映射,然后重启引起中断的指令。

    最后可以发现分页机制使我们的程序更加细腻了,运行的粒度是页而不是整个进程,大大提高了效率。

    页表

    上面说到虚拟内存到物理内存有个映射,这个映射我们知道是MMU做的,但是它是如何实现的?最简单的办法就是需要有一张类似hash表的结构来查看,比如页面1对应的页框是10,那么就记录成hash[1]=10,但是这仅仅是定位到了页框,具体的位置还没定位到,也就是类似偏移量的数据没有。不猜了,我们直接来看看MMU是如何做到的,以一个16位的虚拟地址,并且页面和页框都是4K的情况来说,MMU会把前4位当作是索引,也就是定位到页框的序号,后12位作为偏移量,这里为什么是12位,很巧妙,因为2^12=4K,正好给每个页框里的数据上了个标号。因此我们只需要根据前4位找到对应的页框即可,然后偏移量就是后12位。找页框就是去我们即将要说的页表里去找,页表除了有页面对应的页框后,还有个标志位来表示对应的页面是否有映射到对应的页框,缺页中断就是根据这个标志位来的。

    可以看出页表非常关键,不仅仅要知道页框、以及是否缺页,其实页表还有保护位修改位访问位高速缓存禁止位

    • 保护位:指的是一个页允许什么类型的访问,常见的是用三个比特位分别表示执行
    • 修改位:有时候也称为脏位,由硬件自动设置,当一个页被修改后,也就是和磁盘的数据不一致了,那么这个位就会被标记为1,下次在页框置换的时候,需要把脏页刷回磁盘,如果这个页的标记为0,说明没有被修改,那么不需要刷回磁盘,直接把数据丢弃就行了。
    • 访问位:当一个页面不论是发生读还是发生写,该页面的访问位都会设置成1,表示正在被访问,它的作用就是在发生缺页中断时,根据这个标志位优先在那些没有被访问的页面中选择淘汰其中的一个或者多个页框。
    • 高速缓存禁止位:对于那些映射到设备寄存器而不是常规内存的页面而言,这个特性很重要,加入操作系统正在紧张的循环等待某个IO设备对它刚发出的指令做出响应,保证这个设备读的不是被高速缓存的副本非常重要。

    TLB快表加速访问

    通过页表我们可以很好的实现虚拟地址到物理地址的转换,然而现代计算机至少是32位的虚拟地址,以4K为一页来说,那么对于32位的虚拟地址,它的页表项就有2^20=1048576个,无论是页表本身的大小还是检索速度,这个数字其实算是有点大了。如果是64位虚拟的地址,按照这种方式的话,页表项将大到超乎想象,更何况最重要的是每个进程都会有一个这样的页表

    我们知道如果每次都要在庞大的页表里面检索页框的话,效率一定不是很高。而且计算机的设计者们观察到这样一种现象:大多数程序总是对少量的页进行多次访问,如果能为这些经常被访问的页单独建立一个查询页表,那么速度就会大大提升,这就是快表,快表只会包含少量的页表项,通常不会超过256个,当我们要查找一个虚拟地址的时候。首先会在快表中查找,如果能找到那么就可以直接返回对应的页框,如果找不到才会去页表中查找,然后从快表中淘汰一个表项,用新找到的页替代它。

    总体来说,TLB类似一个体积更小的页表缓存,它存放的都是最近被访问的页,而不是所有的页。

    多级页表

    TLB虽然一定程度上可以解决转换速度的问题,但是没有解决页表本身占用太大空间的问题。其实我们可以想想,大部分程序会使用到所有的页面吗?其实不会。一个进程在内存中的地址空间一般分为程序段、数据段和堆栈段,堆栈段在内存的结构上是从高地址向低地址增长的,其他两个是从低地址向高地址增长的。

    可以发现中间部分是空的,也就是这部分地址是用不到的,那我们完全不需要把中间没有被使用的内存地址也引入页表呀,这就是多级页表的思想。以32位地址为例,后12位是偏移量,前20位可以拆成两个10位,我们暂且叫做顶级页表和二级页表,每10位可以表示2^10=1024个表项,因此它的结构大致如下:

     对于顶级页表来说,中间灰色的部分就是没有被使用的内存空间。顶级页表就像我们身份证号前面几个数字,可以定位到我们是哪个城市或者县的,二级页表就像身份证中间的数字,可以定位到我们是哪个街道或者哪个村的,最后的偏移量就像我们的门牌号和姓名,通过这样的分段可以大大减少空间,我们来看个简单的例子:

    如果我们不拆出顶级页表和二级页表,那么所需要的页表项就是2^20个,如果我们拆分,那么就是1个顶级页表+2^10个二级页表,两者的存储差距明显可以看出拆分后更加节省空间,这就是多级页表的好处。

    当然我们的二级也可以拆成三级、四级甚至更多级,级数越多灵活性越大,但是级数越多,检索越慢,这一点是需要注意的。


    最后

    为了便于大家理解,本文画了20张图,肝了将近7000多字,创作不易,各位的三连就是对作者最大的支持,也是作者最大的创作动力。

    微信搜一搜【假装懂编程】,加入我们,与作者共同学习,共同进步。

     

    往期精彩:

    展开全文
  • 这两天在为一个应用做solr搜索方案定制的过程中,需要用到solr的fieldcache,在估算fieldcache需要的内存容量,缓存中key是int,value是两个64bit大小的long类型数组,数据量大约是8100w,64×8100w/1024/1024,大致...

          这两天在为一个应用做solr搜索方案定制的过程中,需要用到solr的fieldcache,在估算fieldcache需要的内存容量,缓存中key是int,value是两个64bit大小的long类型数组,数据量大约是8100w,64×8100w/1024/1024,大致需要10G的容量,

     然而服务器总共也只有8G内存,实在无法支持这么大容量的缓存数据。

             

        于是开始想是不是可以有其他的替换的方案,可以不需要使用这么大的缓存容量,有能满足缓存的需要。考虑是不是可以将fieldcache中的数据内存存放到硬盘中去,在调用的时候可以通过key值快速计算出文档中的偏移量从而量数据取出,因为直观感觉只要知道一个文件偏移量而取内存应该是很快的。

              

        光有感觉是不行的,还需要实际测试一下,测试硬盘访问速度到底和内存访问速度相差多大。

     

      初始化测试数据       

        分别写一个向内存中和向硬盘中写数据的代码,内容如下:

    1. 向内存中写
      Map<Integer, Long[]> data = new HashMap<Integer, Long[]>();
      
      for (int i = 0; i < 2000000; i++) {
      	data.put(i, new Long[] { (long) (i + 1), (long) (i + 2) });
      }

       

    2. 向硬盘中写
      import java.io.File;
      import java.io.RandomAccessFile;
      
      import org.apache.lucene.analysis.Analyzer;
      import org.apache.lucene.analysis.payloads.PayloadHelper;
      import org.apache.lucene.analysis.standard.StandardAnalyzer;
      import org.apache.lucene.document.Document;
      import org.apache.lucene.document.Field;
      import org.apache.lucene.index.IndexWriter;
      import org.apache.lucene.index.IndexWriterConfig;
      import org.apache.lucene.index.IndexWriterConfig.OpenMode;
      import org.apache.lucene.store.Directory;
      import org.apache.lucene.store.SimpleFSDirectory;
      import org.apache.lucene.util.Version;
      
      public class DocReplication {
      
      	public static Analyzer analyzer;
      	static {
      		analyzer = new StandardAnalyzer(Version.LUCENE_34);
      	}
      
      	public static void main(String[] arg) throws Exception {
      		RandomAccessFile randomFile = new RandomAccessFile(new File(
      				"DocReplication.text"), "rw");
      
      		Directory dir = new SimpleFSDirectory(new File("indexdir"));
      
      		IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_34,
      				analyzer);
      		iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
      		IndexWriter writer = new IndexWriter(dir, iwc);
      
      		for (int i = 0; i < 2000000; i++) {
                              // 向一个随机访问文件中写
      			randomFile.write(PayloadHelper.encodeInt(i));
      			randomFile.write(long2Array(i + 1));
      			randomFile.write(long2Array(i + 2));
                              // 向lucene中document中写
      			Document doc = new Document();
      			doc.add(new Field("id", String.valueOf(i), Field.Store.YES,
      					Field.Index.NOT_ANALYZED_NO_NORMS));
      			doc.add(new Field("id2", String.valueOf(i), Field.Store.YES,
      					Field.Index.NOT_ANALYZED_NO_NORMS));
      			writer.addDocument(doc);
      			System.out.println("point:" + randomFile.getFilePointer());
      		}
      		writer.commit();
      		writer.close();
      		randomFile.close();
      	}
      
      	static byte[] long2Array(long val) {
      
      		int off = 0;
      		byte[] b = new byte[8];
      		b[off + 7] = (byte) (val >>> 0);
      		b[off + 6] = (byte) (val >>> 8);
      		b[off + 5] = (byte) (val >>> 16);
      		b[off + 4] = (byte) (val >>> 24);
      		b[off + 3] = (byte) (val >>> 32);
      		b[off + 2] = (byte) (val >>> 40);
      		b[off + 1] = (byte) (val >>> 48);
      		b[off + 0] = (byte) (val >>> 56);
      		return b;
      
      	}
      }

       以上向内存中和向硬盘中写都是写200w条数据,在执行向硬盘中写的过程中分别是向lucene的索引文件和向RandomAccessFile随机文件中写,下面介绍一下用RandomAccessFile写的文件结构,文件中一条记录的数据结构,如图:

       一条记录的长度为20字节,只要拿到docid也就是key值就能计算出
      RandomAccessFile的文件偏移量=docid × 20。

         至于为什么要向lucene索引文件中写的原因是,想比较一下通过lucene的 indexread.get(docid) 方法取得到document的fieldvalue 的访问速度,和用RandomAccessFile访问缓存值的速度到底谁更快。

     

    编写读数据测试案例

    1. 从自定义随机文件中读取
      public static void main(String[] args) throws Exception {
      
      		RandomAccessFile randomFile = new RandomAccessFile(new File(
      				"DocReplication.text"), "rw");
      
      		long current = System.currentTimeMillis();
      
      		for (int i = 0; i < 100000; i++) {
      
      			int docid = (int) (Math.random() * 2000000);
      			randomFile.seek(docid * 20 + 4);
      
      			randomFile.readLong();
      			randomFile.readLong();
      
      		}
      
      		System.out.println((System.currentTimeMillis() - current) / 1000);
      
      		randomFile.close();
      
      	}

       

    2. 从内存中读取
      public static void main(String[] args) {
      		Map<Integer, Long[]> data = new HashMap<Integer, Long[]>();
      
      		for (int i = 0; i < 2000000; i++) {
      			data.put(i, new Long[] { (long) (i + 1), (long) (i + 2) });
      		}
      		long start = System.currentTimeMillis();
      		Long[] row = null;
      		long tmp = 0;
      		for (int i = 0; i < 100000; i++) {
      			int doc = (int) (Math.random() * 2000000);
      			row = data.get(doc);
      			tmp = row[0];
      			tmp = row[1];
      		}
      		System.out.println((System.currentTimeMillis() - start) );
      	}

       

    3. 从lucene索引文件中随机访问
      public static void main(String[] args) throws Exception {
      	Directory dir = new SimpleFSDirectory(new File("indexdir"));
      	long start = System.currentTimeMillis();
      	IndexReader reader = IndexReader.open(dir);
      	Document doc = null;
      	for (int i = 0; i < 100000; i++) {
      		int docid = (int) (Math.random() * 2000000);
      		doc = reader.document(docid);
      		doc.get("id");
      		doc.get("id2");
      	}
      
      	System.out.println("consume:" + (System.currentTimeMillis() - start)/ 1000);
      }

       三个测试案例,都是从目标存储中从有200w数据量的cache中随机取出一个key,通过key取到value,这样的过程重复10w次,看看需要花费多少时间。

    测试结果:

      从自定义随机文件中读取  从内存中读取  从lucene索引文件中随机访问
     总耗时 3717ms 75ms 1673ms

     

        从测试结果看,通过内存读cache是最快的,无疑和预想的结果是一致的,但是本来以为从自定义的随机文件中读取速度要比从lucene的indexreader来取要快些,但从测试结果看恰恰相反,从lucene的indexreader要比自定义随机文件快差不多一倍。

       比较之下,内存和磁盘的访问速度比是75比1673=1比22,速度还是相差挺大的,我很好奇,要是将磁盘改成SSD存储介质的话,磁盘访问速度会有多大提升,无奈现在测试环境中还没有SSD的服务器,改天找一台来测试一下,到时候再将测试结果公布一下。

    展开全文
  • documentlinux内存机制CPU内存虚拟内存硬盘物理内存内存和虚拟内存跟 Windows 完全不同的 Linux 内存机制Swap配置对性能的影响 linux内存机制 Linux支持虚拟内存(Virtual Mmemory),虚拟内存是指使用磁盘当作RAM的...

    本文有些篇幅较长,但如果认真读下来,相信你会收获颇丰!!


    在这里插入图片描述

    linux内存机制

    Linux支持虚拟内存(Virtual Mmemory),虚拟内存是指使用磁盘当作RAM的扩展,这样可用的内存的大小就相应地增大了。内核会将暂时不用的内存块的内容写到硬盘上,这样一来,这块内存就可用于其它目的。当需要用到原始的内容时,它们被重新读入内存。这些操作对用户来说是完全透明的;Linux下运行的程序只是看到有大量的内存可供使用而并没有注意到时不时它们的一部分是驻留在硬盘上的。当然,读写硬盘要比直接使用真实内存慢得多(要慢数千倍),所以程序就不会象一直在内存中运行的那样快。用作虚拟内存的硬盘部分被称为交换空间(Swap Space)

    一般,在交换空间中的页面首先被换入内存;如果此时没有足够的物理内存来容纳它们又将被交换出来(到其他的交换空间中)。如果没有足够的虚拟内存来容纳所有这些页面,Linux就会波动而不正常;但经过一段较长的时间Linux会恢复,但此时系统已不可用了。

    有时,尽管有许多的空闲内存,仍然会有许多的交换空间正被使用。这种情况是有可能发生的,例如如果在某一时刻有进行交换的必要,但后来一个占用很多物理内存的大进程结束并释放内存时。被交换出的数据并不会自动地交换进内存,除非有这个需要时。此时物理内存会在一段时间内保持空闲状态。对此并没有什么可担心的,但是知道了是怎么一回事,也就无所谓了。许多操作系统使用了虚拟内存的方法。因为它们仅在运行时才需要交换空间,以解决不会在同一时间使用交换空间,因此,除了当前正在运行的操作系统的交换空间,其它的就是一种浪费。所以让它们共享一个交换空间将会更有效率。

    注意:如果会有几个人同时使用这个系统,他们都将消耗内存。然而,如果两个人同时运行一个程序,内存消耗的总量并不是翻倍,因为代码页以及共享的库只存在一份。Linux系统常常动不动就使用交换空间,以保持尽可能多的空闲物理内存。即使并没有什么事情需要内存,Linux也会交换出暂时不用的内存页面。这可以避免等待交换所需的时间:当磁盘闲着,就可以提前做好交换。可以将交换空间分散在几个硬盘之上。针对相关磁盘的速度以及对磁盘的访问模式,这样做可以提高性能。与访问物理内存相比,磁盘的读写是很慢的。另外,在相应较短的时间内多次读磁盘同样的部分也是常有的事。例如,某人也许首先阅读了一段E-mail消息,然后为了答复又将这段消息读入编辑器中,然后又在将这个消息拷贝到文件夹中时,使得邮件程序又一次读入它。或者考虑一下在一个有着许多用户的系统中 ls命令会被使用多少次。通过将信息从磁盘上仅读入一次并将其存于内存中,除了第一次读以外,可以加快所有其它读的速度。这叫作磁盘缓冲(Disk Buffering),被用作此目的的内存称为高速缓冲(Buffer Cache)。但是,由于内存是一种有限而又不充足的资源,高速缓冲不可能做的很大(它不可能包容要用到的所有数据)。当缓冲充满了数据时,其中最长时间不用的数据将被舍弃以腾出内存空间用于新的数据。对写磁盘操作来说磁盘缓冲技术同样有效。一方面,被写入磁盘的数据常常会很快地又被读出(例如,原代码文件被保存到一个文件中,又被编译器读入),所以将要被写的数据放入缓冲中是个好主意。另一方面,通过将数据放入缓冲中,而不是将其立刻写入磁盘,程序可以加快运行的速度。以后,写的操作可以在后台完成,而不会拖延程序的执行。

    大多数操作系统都有高速缓冲(尽管可能称呼不同),但是并不是都遵守上面的原理。有些是直接写(Write-Through):数据将被立刻写入磁盘(当然,数据也被放入缓存中)。如果写操作是在以后做的,那么该缓存被称为后台写(Write-Back)。后台写比直接写更有效,但也容易出错:如果机器崩溃,或者突然掉电,缓冲中改变过的数据就被丢失了。如果仍未被写入的数据含有重要的薄记信息,这甚至可能意味着文件系统(如果有的话)已不完整。
    针对以上的原因,出现了很多的日志文件系统,数据在缓冲区修改后,同时会被文件系统记录修改信息,这样即使此时系统掉电,系统重启后会首先从日志记录中恢复数据,保证数据不丢失。当然这些问题不再本文的叙述范围。由于上述原因,在使用适当的关闭过程之前,绝对不要关掉电源,Sync命令倾空(Flushes)缓冲,也即,强迫所有未被写的数据写入磁盘,可用以确定所有的写操作都已完成。在传统的UNIX系统中,有一个叫做update的程序运行于后台,每隔30秒做一次sync操作,因此通常无需手工使用sync命令了。Linux另外有一个后台程序,Bdflush,这个程序执行更频繁的但不是全面的同步操作,以避免有时sync的大量磁盘I/O操作所带来的磁盘的突然冻结。在Linux中,Bdflush是由update启动的。通常没有理由来担心此事,但如果由于某些原因bdflush进程死掉了,内核会对此作出警告,此时你就要手工地启动它了(/sbin/update)。

    **缓存(Cache)**实际并不是缓冲文件的,而是缓冲块的,块是磁盘I/O操作的最小单元(在Linux中,它们通常是1KB)。这样,目录、超级块、其它文件系统的薄记数据以及非文件系统的磁盘数据都可以被缓冲了。缓冲的效力主要是由它的大小决定的。缓冲太小的话等于没用。它只能容纳一点数据,因此在被重用时,所有缓冲的数据都将被倾空。实际的大小依赖于数据读写的频次、相同数据被访问的频率。只有用实验的方法才能知道。如果缓存有固定的大小,那么缓存太大了也不好,因为这会使得空闲的内存太小而导致进行交换操作(这同样是慢的)。为了最有效地使用实际内存,Linux自动地使用所有空闲的内存作为高速缓冲,当程序需要更多的内存时,它也会自动地减小缓冲的大小。这就是一般情况下Linux内存的一般机制,真正的Linux内存的运行机制远远比这个复杂

    CPU

    CPU即中央处理器,是英语“Central Processing Unit”的缩写。CPU从内存或
    缓存中取出指令,放入指令寄存器,并对指令译码分解成一系列的微操作,然后发出各种控制命令,执行微操作系列,从而完成一条指令的执行。

    内存

    但是,CPU并不能直接调用存储在硬盘上的系统、程序和数据,必须首先将硬盘的有关内容存储在内存中,这样才能被CPU读取运行。因而,内存(即物理内存,是相对于硬盘这个“外存”而言)作为硬盘和CPU的“中转站”,对电脑运行速度有较大影响。

    虚拟内存

    当运行数据超出物理内存容纳限度的时候,部分数据就会自行“溢出”,这时系统就会将硬盘上的部分空间模拟成内存——虚拟内存,并将暂时不运行的程序或不使用的数据存放到这部分空间之中,等待需要的时候方便及时调用。

    硬盘

    由于内存是带电存储的(一旦断电数据就会消失),而且容量有限,所以要长时间储存程序或数据就需要使用硬盘(外存储器)。硬盘也会影响系统速度,因为系统从硬盘中读取数据并通过总线存入内存的速度也会影响系统运行的快慢

    物理内存

    物理内存是真正的内存,在应用中顾名思义,物理上,真实的插在板子上的内存是多大就是多大了。看机器配置的时候,看的就是这个物理内存。虚拟内存是为了满足系统对超出物理内存容量的需求时在外存(如硬盘)上开辟的存储空间。由于虚拟内存其实是放在外存上,因而与物理内存相比读写速度都非常慢

    内存和虚拟内存

    内存在计算机中的作用很大,电脑中所有运行的程序都需要经过内存来执行,如果执行的程序很大或很多,就会导致内存消耗更大。为了解决这个问题,可以使用虚拟内存技术,即拿出一部分硬盘空间来充当内存使用,当内存占用完时,电脑就会自动调用硬盘来充当内存,以缓解内存的紧张。比如说当电脑要读取一个比物理内存还要大的文件时,就要用到虚拟内存,文件被内存读取之后就会先储存到虚拟内存,等待内存把文件全部储存到虚拟内存之后,就把虚拟内里储存的文件释放到原来的目录里了。

    跟 Windows 完全不同的 Linux 内存机制

    在 Linux 中经常发现空闲内存很少,似乎所有的内存都被系统占用了,表面感觉是内存不够用了,其实不然。这是 Linux 内存管理的一个优秀特性,在这方面,区别于 Windows 的内存管理。主要特点是,无论物理内存有多大,Linux 都将其充份利用,将一些程序调用过的硬盘数据读入内存,利用内存读写的高速特性来提高 Linux 系统的数据访问性能。而 Windows 是只在需要内存时,才为应用程序分配内存,并不能充分利用大容量的内存空间。换句话说,每增加一些物理内存,Linux 都将能充分利用起来,发挥了硬件投资带来的好处,而 Windows 只将其做为摆设,即使增加 8GB 甚至更大。
    在这里插入图片描述

    Linux 的这一特性,主要是利用空闲的物理内存,划分出一部份空间,做为 cache 和 buffers ,以此提高数据访问性能。

    页高速缓存(cache)是 Linux内核实现的一种主要磁盘缓存。它主要用来减少对磁盘的I/O操作。具体地讲,是通过把磁盘中的数据缓存到物理内存中,把对磁盘的访问变为对物理 内存的访问。

    磁盘高速缓存的价值在于两个方面:

    1. 访问磁盘的速度要远远低于访问内存的速度,因此,从内存访问数据比从磁盘访问速度更快;
    2. 数据一旦被访 问,就很有可能在短期内再次被访问到。

    综上所述,一般不需要太关注Linux的内存占用情况,如果SWAP占用率很高的话一般可能就是内存不够用了。

    Swap配置对性能的影响

    分配太多的Swap空间会浪费磁盘空间,而Swap空间太少,则系统会发生错误。如果系统的物理内存用光了,系统就会跑得很慢,但仍能运行;如果Swap空间用光了,那么系统就会发生错误。例如,Web服务器能根据不同的请求数量衍生出多个服务进程(或线程),如果Swap空间用完,则服务进程无法启动,通常会出现“application is out of memory”的错误,严重时会造成服务进程的死锁。因此Swap空间的分配是很重要的。

    通常情况下,Swap空间应大于或等于物理内存的大小,最小不应小于64M,通常Swap空间的大小应是物理内存的2-2.5倍。但根据不同的应用,应有不同的配置:如果是小的桌面系统,则只需要较小的Swap空间,而大的服务器系统则视情况不同需要不同大小的Swap空间。特别是数据库服务器和Web服务器,随着访问量的增加,对Swap空间的要求也会增加,一般来说对于4G以下的物理内存,配置2倍的swap,4G以上配置1倍。

    另外,Swap分区的数量对性能也有很大的影响。因为Swap交换的操作是磁盘IO的操作,如果有多个Swap交换区,Swap空间的分配会以轮流的方式操作于所有的Swap,这样会大大均衡IO的负载,加快Swap交换的速度。如果只有一个交换区,所有的交换操作会使交换区变得很忙,使系统大多数时间处于等待状态,效率很低。用性能监视工具就会发现,此时的CPU并不很忙,而系统却慢。这说明,瓶颈在IO上,依靠提高CPU的速度是解决不了问题的。

    展开全文
  • 记录一次spring-boot程序内存泄露排查

    千次阅读 2019-01-09 11:30:43
    spring boot项目jvm启动配置-Xms4g -Xmx4g,然而很不幸的是程序所占的内存越来越高,都达到了12个多G,只能临时重启服务 排查一:开发环境和测试环境调试 用jdk自带的jvisualvm.exe,查看最占空间的类和实例最多的类...

    现象

    spring boot项目jvm启动配置-Xms4g -Xmx4g,然而很不幸的是程序所占的内存越来越高,都达到了12个多G,只能临时重启服务

    常用命令

    • jstat -class PID
    • jstat -compiler PID
    • jstat -gc PID
    • jstat -gccapacity PID
    • jstat -gcutil PID 查看堆比例
    • jstat -gccause PID
    • jstat -gcnew PID
    • jstat -gcnewcapacity PID
    • jstat -gcold PID
    • jstat -gcoldcapcacity PID
    • jstat -printcompilation PID
    • jmap -histo PID 查看类的实例
    • jmap -heap PID 查看堆栈信息
    • jmap -dump:live,format=b,file=/tmp/m.hprof PID 保存内存的堆栈为文件
    • jhat -J-Xmx2048m -port 5000 /tmp/m.hprof 在线查看堆文件的类,速度比较慢
    • jcmd PID GC.run 强制gc

    排查一:开发环境和测试环境调试

    用jdk自带的jvisualvm.exe,查看最占空间的类和实例最多的类,找到其最近的内存释放点一般就是内存泄露对象,也可以用jmap查看jvm进程实例最多的类

    1. 本机启动程序,postman或者jmeter调用程序接口,可以直接直接用jvisualvm查看到堆栈信息
    2. 远程调试,在测试环境启用jmxremote,-Dcom.sun.management.jmxremote.port=10096 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false
      但是堆栈信息只能先保存在测试服务器上,下载到本地后再用jvisualvm.exe打开

    排查二:保存生成环境的内存进行分析

    先用jmap命令将程序的内存数据保存下来,jmap -dump:live,format=b,file=m.hprof PID,其中PID是程序的进程号

    /data/server/jdk/jdk1.8.0_171/bin/jmap -dump:live,format=b,file=/tmp/m.hprof 3478
    
    • 将/tmp/m.hprof堆栈文件下载到本地电脑,用jvisualvm.exe打开分析,生产服务器外网太小,下载好慢
    • mat分析,我是在一台空闲一点的生成服务器上使用,阿里云内网传输文件速度特别快,将下载的mat直接解压缩就可以使用了,因为文件太大内存不足所以需要修改 MemoryAnalyzer.ini中的参数-Xmx4096M
      cd /data/tools/mat
      ./ParseHeapDump.sh /tmp/m.hprof org.eclipse.mat.api:suspects org.eclipse.mat.api:overview org.eclipse.mat.api:top_components
      程序执行完以后会在/tmp下面生成一堆文件,其中 m_System_Overview.zip ,m_Top_Components.zip,m_Leak_Suspects.zip三个压缩文件就是报告了,可以看到程序的运行概况,最大的对象,和推测泄露点
      在这里插入图片描述
      从我的内存泄露报告中可以看到Global对象groovy.lang.MetaClassImpl对象是两个主要的内存泄露点

    解决

    1)复查程序发现将groovy脚本封装到了一个ThreadLocal中,在一次请求中可以被重复利用,该ThreadLocal包括了Global对象,在函数处理结束后释放掉ThreadLocal对象,主要内存泄漏点得到修复
    2)groovy.lang.MetaClassImpl泄露解决,先升级groovy-all的版本
    发现很多的实例其实已经没有引用了,但是内存得不到释放,当系统内存不足的时候才会被释放掉
    最终解决:

    • spring-boot升级到2.1.1.RELEASE
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
        <type>pom</type>
    </dependency>
    
    • 废用tomcat容器,改用undertow当做容器
           <dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    			<exclusions>
    				<exclusion>
    					<groupId>org.springframework.boot</groupId>
    					<artifactId>spring-boot-starter-tomcat</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-undertow</artifactId>
    		</dependency>
    

    3)java启动参数的顺序调整
    生产服务器上有些spring-boot工程的-Xmx生效,有些没有生效,并且所有的jar包jvm参数全部放到了jar包的后面
    经过测试如果在本地电脑把参数放在jar包的后面是无效的
    正确的写法: java -jar -Xmx2048m -Xms1024m test.jar --spring.profiles.active=prod

    好的内存排查文章

    Spring Boot引起的“堆外内存泄漏”排查及经验总结

    展开全文
  • 什么是内存泄露?怎么检测

    千次阅读 2019-03-20 17:32:03
    什么是内存泄露? 简单地说就是申请了一块内存空间,使用完毕后没有释放掉。它的一般表现方式是程序运行时间越长,占用内存越多,最终用尽全部内存,整个系统崩溃。由程序申请的一块内存,且没有任何一个指针指向它...
  • 一个由 C/C++ 编译的程序占用的内存分为以下几个部分 : 栈区( stack ) ——由编译器自动分配释放,存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。其操作方式类似于数据结构中的栈; 堆区( ...
  • heap:是由malloc之类函数分配的...一个由c/C++编译的程序占用的内存分为以下几个部分 1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区(h
  • 堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,...
  • 日期 内核版本 架构 作者 GitHub CSDN 2016-08-31 Linux-4.7 X86 & arm ... Linux内存管理 http://blog.csdn.net/vanbreaker/article/details/75799411 前景回顾前面我们讲到服务器体系(SMP, NUMA, M
  • 连续内存分配与非连续内存分配

    千次阅读 2018-09-22 08:45:03
    连续内存分配 首次适配:空闲分区以地址递增的次序链接。分配内存时顺序查找,找到大小能满足要求的第一个空闲分区。 最优适配:空闲分区按容量递增形成分区链,找到第一个能满足要求的空闲分区。 最坏适配:空闲...
  • 内存和栈内存详解

    万次阅读 多人点赞 2014-10-04 17:50:01
    堆:顺序随意 栈:先进后出 堆和栈的区别 一、预备知识—程序的内存分配 一个由c/C++编译的程序占用的内存分为以下几个部分 1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。...
  • 日期 内核版本 架构 作者 GitHub CSDN 2016-08-31 ... Linux内存管理 1 前景回顾前面我们讲到服务器体系(SMP, NUMA, MPP)与共享存储器架构(UMA和NUMA)1.1 UMA和NUMA两种模型共享存储型多处理机有两种模型
  • 内存和栈内存的区别

    万次阅读 2019-03-14 00:03:46
    否则发生内存泄露。典型为使用new申请的堆内容。 除了这两部分,还有一部分是: 3 静态存储区:内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。 转自...
  • 比如:页的大小为 4K,那么 4GB 存储空间就需要 4GB/4KB=1M 条记录,即有 100 多万个 4KB 的页。我们可以相待,如果页太小了,那么就会产生大量的页表条目,降低了查询速度的同时还浪费了存放页面的主存空间;但如果...
  • 深入理解Java虚拟机-Java内存区域与内存溢出异常

    万次阅读 多人点赞 2020-01-03 21:42:24
    Java与C++之间有一堵由内存动态分配和垃圾收集技术所围成的"高墙",墙外面的人想进去,墙里面的人却想出来。 文章目录概述运行时数据区域程序计数器(线程私有)Java虚拟机栈(线程私有)局部变量表操作数栈动态链接...
  • 记录下我的惠普电脑加装内存

    千次阅读 2020-09-02 11:52:14
    一确定电脑自带的内存条型号, 先看电脑的内存条插槽和允许的最大内存:确定电脑是不是可以加装; 按下win+r键,在运行框输入cmd按回车 在命令框中输入:wmic ...可以看到我这边的内存运行速度是2400Mhz,看configured
  • JVM内存分配与管理详解

    万次阅读 2018-01-23 16:17:58
    了解C++的程序员都知道,在内存管理领域,都是由程序员维护与管理,程序员用于最高的管理权限,但对于java程序员来说,在内存管理领域,程序员不必去关心内存的分配以及回收,在jvm自动内存管理机制的帮助下,不需要...
  • 一文详解堆栈(二)——内存堆与内存

    万次阅读 多人点赞 2019-10-15 19:06:15
    前言:我们经常听见一个概念,堆(heap)和栈(stack),其实在数据结构中也有同样的这两个概念,但是这和内存的堆栈是不一样的东西哦,本文也会说明他们之间的区别的,另外,本文的只是是以C/C++为背景来说明,不同...
  • 除了简单方便易上手,跨平台可移植,各种函数库支持类应有尽有不用重复造轮子这些特性之外,恐怕就是速度慢,占用内存高了吧。不可否认,java运行速度内存占用方便确实无法比肩C/C++。随手举一个很直观的栗子,在...
  • Linux是如何避免内存碎片的

    万次阅读 多人点赞 2018-03-23 19:37:01
    Linux是如何避免内存碎片的? 在网上看到这个面试题,参考答案是这样的: 伙伴算法,用于管理物理内存,避免内存碎片; 高速缓存Slab层用于管理内核分配内存,避免碎片。 故继而去深入了解了一波,做了一个...
  • Java内存划分和分配

    千次阅读 2018-10-18 15:03:41
    在了解Java每个内存区域的功能之后,进一步分析Java对象如何的创建和对象的内存分配,以及如何访问对象中的内存。最后学习一下Java堆内存的分代划分和内存分配。 Java内存区域划分 首先通过一张图来看一下Java虚拟机...
  • 【Linux】Linux的虚拟内存详解(MMU、页表结构)

    万次阅读 多人点赞 2018-07-16 20:16:28
    内存是程序得以运行的重要物质基础。如何在有限的内存空间运行较大的应用程序,曾是困扰人们的一个难题。为解决这个问题,人们设计了许多的方案,其中最成功的当属虚拟内存技术。Linux作为一个以通用为目的的现代...
  • 【Git学习】解决GitLab内存消耗大的问题

    万次阅读 多人点赞 2018-11-20 09:27:42
    今天有提示反馈Gitlab服务器push不上去,让我看看是不是Gitlab服务器出了什么问题。 我查看了下gitlab在线的信息 这台服务器消耗了31.3GB内存。 然后我11:14分尝试去连接Gitlab服务器,发现要很久很久才连接...
  • 上线三个月累计数据800万,但是今天突然大面积出现查询超时,上服务器查看服务运行情况,发现cpu使用率高达300% mem 使用率也到了90%,下面记录了整个排查问题的过程 1.首先查看elastic cpu和mem占用情况 ...
  • 记一次堆外内存溢出排查过程

    万次阅读 2018-09-30 12:58:14
    服务器发布/重启后,进程占用内存 21%(3g),观察进程占用内存,以一天4%左右的速度增长,一定时间过后,java 进程内存增长到接近 90%,服务器报警。此时 old 区占用 50%,未达到 CMS GC 阈值,因此不会触发 CMS GC,...
  • 一般情况下mysql上百万数据读取和插入更新是没什么问题了,但到了上千万级就会出现很慢,下面我们来看mysql千万级数据库插入速度和读取速度的调整记录吧。   (1)提高数据库插入性能中心思想:尽量将数据一...
  • 日期 内核版本 架构 作者 GitHub CSDN 2016-06-14 ...在内存管理的上下文中, 初始化(initialization)可以有多种含义. 在许多CPU上, 必须显式设置适用于Linux内核的内存模型. 例如在x86_32上需要切换
  • 理解Redis的内存

    万次阅读 多人点赞 2018-09-08 21:24:45
    Redis的所有的数据都是存在了内存中的,虽然现在内存越来越便宜,但是跟平时电脑上装的硬盘相比,硬盘的价格就是个渣渣。内存还是非常宝贵的,就拿我的一台腾讯云的服务器来说,目前是1核2G的,但是要想升级到4G,
  • 内存溢出是指应用系统中存在无法回收的内存或使用的内存过多,最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。  引起内存溢出的原因有很多种,常见的有以下几种: 1.内存中加载的数据量过于庞大,如一...
  • 你还不懂硬盘,内存和CPU的关系 ?(程序员入门)

    千次阅读 多人点赞 2020-06-05 10:42:04
    文章目录一、硬盘内存CPU图二、硬盘讲解三、内存的简介四、拓展A盘和B盘 一、硬盘内存CPU图 二、硬盘讲解 硬盘简介 ①电脑硬盘是计算机最主要的存储设备。 ②硬盘(港台称之为硬碟,英文名:Hard Disk Drive, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 417,573
精华内容 167,029
关键字:

记录内存的速度是什么

友情链接: MFC资源大全8.rar