上篇讲了”网站SEO关键词布局操作大全“，这篇讲链接，网站是通过一个一个链接搭建到一块的，所有网站之间以及网站和用户之间也都是通过链接进行联系起来的，同样也是搜索引擎爬取和识别的线路，那么都有哪类链接？他们的作用是什么？应该注意什么问题？下面就把所有有关链接方面的知识整理收集到一块，方便大家学习研究。
 
 
 
 
 一、常见链接类型
 
 为了方便，把链接也分出了很多种，每种链接都有其自己相应的作用，同时链接直接也有共同和相通的地方，如果我们知道了这些链接的种类和作用，使用起来是不是更方便。
 
 
 什么是反向链接？
 
 
 什么是外部链接？
 
 
 什么是内部链接？
 
 
 什么是锚文本链接？
 
 
 什么是超链接？
 
 
 什么是错误链接？
 
 
 什么是友情链接？
 
 
 什么是面包屑型链接？
 
 
 什么是导入链接？
 
 
 什么是死链接？
 
 
 什么是导出链接？
 
 二、友情链接交换
 
 只所以单独讲友情链接，因为它一直在优化中占重要作用，随着搜索引擎对各种链接的筛选和打击（绿萝算法、绿萝算法2.0），目前真正起作用的外链越来越少，但友情链接的作用和地位一直没受到过影响，需要好好了解。
 
 
 全面分析网站如何进行友情链接的交换
 
 
 友情链接检查工具的使用
 
 
 交换友链注意潜规则问题
 
 
 友链SEO工具：换链神器测试体验
 
 三、外链发布技巧
 
 虽然外链在网站优化中的比重越来越小，但对于SEO的作用还非常的大，这也是搜索引擎做排名是必须考虑的一方面，现在很多外链被视为垃圾外链，不过还是有很多发布高质量外链的方法技巧值得我们学习。
 
 
 批量拒绝外链的最快方法
 
 
 如何模拟真实用户做自然外链
 
 
 外链的表现形式有哪几种？
 
 
 增加外链的一些注意事项
 
 
 如何打造高质量外链
 
 
 如何查看竞争对手最新的外链
 
 
 Xenu-死链接检测工具
 
 
 如何打造成功的外链
 
 
 新手必看：网站外链建设全面大解析
 
 
 新手必看：网站内部链接优化大解析
 
 四、外链建设思考
 
 主要是谈谈外链的必要性以及如果做才能投入最少的精力获取最大的效果，可以说是外链建设技巧的进一步思考，不管做什么事情都要有计划和步骤循序渐进，外链很简单却也有很多细节方面需要注意。
 
 
 典型SEO作弊：站群、链轮、买卖链接、链接诱饵
 
 
 SEO每天除了更新文章发发外链还能做什么?
 
 
 什么样的外链是作弊外链？
 
 
 外链是不是就是SEO唯一途径?
 
 
 不相关的外链有用吗？
 
 
 思维拓展：现在外链要怎么做？
 
 
 外链文章没有优势的情况下拿什么与同行竞争
 
 
 SEO思维：未来的网站外链该如何去做？
 
 
 提醒买软文外链的站长：高百度权重网站的猫腻
 
 
 【实用】如何提高外链文章的质量
 
 以上内容是对网站优化链接建设的详细讲解，已经包含了各种链接问题可以说非常全面了，如果能详细的学习和研究那么关于链接建设一定会没有任何问题的，不管是什么学到的东西都要用到实践中，否则一切白搭。
 
 原文地址：http://shenyongxiang.com/syx/1234.html

http://freeeim.blogbus.com/logs/33955659.html
 
链接是网站的灵魂。用户通过超级链接获得丰富的网站内容，搜索引擎蜘蛛也是沿着一个网站的页面链接层层跟踪深入，完成对该网站的信息抓取。对搜索引擎尤其是Google来说，决定一个网站排名的关键，是外部有多少高质量的链接指向这个网站。这就是外部链接或反向链接，也称导入链接（Inbound links或backlinks)。而从网站引向其它网站的导出链接以及网站内部页面间的彼此链接也对排名带来或多或少的影响。
 
导出链接和内部链接 
 
导出链接就是你的网站中指向其它网站的链接。搜索引擎机器人除了分析你的导入链接，也会分析你引出去的站点，如果导出链接站点内容与你的网站主题相关联，同样有利于搜索引擎友好。这也是交换链接要选择主题相关网站的原因。最后，一个网站内页面间的链接也被纳入链接分析之中，影响到网站的页面等级，最终影响排名。 
 
导出链接： 
在你的网站上如果增加一些与你关键词有关的行业／专业的资源性网站链接，不仅有利于丰富网站内容，也有利于提升搜索引擎对你网站的好印象。 
 
这一点尤其值得一些站长注意。由于缺乏原创资料，他们常常转摘其它网站的文章作自己网站的内容，但又不注明来源，惟恐导出链接助长了竞争对手，不利于自己的网站访问量。其实，对搜索引擎来说，适量、适当的导出链接是很有必要的。 
 
当然，导出不同于导入，即使主题相关，也要控制数量。因为从“网页级别”的角度看，搜索引擎认为一个页面奉献的导出链接数量越多，则该网站其它页面的受益相应就减少。所以一个页面导出链接数量应受到合理控制，不要超过15个。首页的导出链接更要控制在１０个以内，多出的应单独安排在次级页面。Google认为一个页面的最大导出链接数量不应超过100个。 
 
内部链接： 
除了导入导出链接，一个站点的页面之间也往往彼此链接，如一篇文章结束后的“相关文章”列表，将该网站中同一主题下的其它文章都链接在内，不仅方便访问者，也有利于搜索引擎。网站应有意识将重要内容页面对次链接于其它页面，让搜索引擎知道这是你的重要页面，从而给予更高的PR值，进行重点索引。 
 
网站还可以通过建立多个二级域名子站，子站间彼此相链，再一起链回主站，形成一个子站群包围主站，对提高排名相当有利。 
 
无论是导出链接还是内部链接，都要保证链接有效而不是死链接，死链过多不仅给用户造成不便，也极不利于搜索引擎友好，影响排名。 
 
关键词链接文本及上下文语意
 
搜索引擎比较重视链接文本中出现的关键词。因此无论是导出链接、导入链接还是内部链接，都最好兼顾到链接文本中含有关键字。比如导出链接最好选择那些有关键词命名的网站，如一个服装厂商的网站可以在行业资源中添加名称中带有“服装”二字的导出链接。 
 
需要注意的是，如果一个网站的导入链接的文本完全相同，则可能遭致搜索引擎忽略或惩罚。因为搜索引擎希望导入链接是别人自然创建的，这种统一文字使搜索引擎怀疑该网站是为了增加链接广度而进行人为制造的结果。因此网站在对外交换友情链接时最好使用不同的文本，如新竞争力的链接文本就包括“新竞争力”“网络营销管理顾问”“深圳竞争力科技公司”等。 
 
除了链接文本，链接周围的文字即上下文(Context) 语意也非常重要。链接分析系统通过检查链接上下文内容来确定网站与其链接对象之间的关联度，以评估该页面的内容质量。通过语意分析，也可以判断出关键词是否作弊。
 
高质量导入链接
 
搜索引擎在决定一个网站的排名时，不仅要对网页内容和结构进行分析，还围绕网站的链接展开分析。对网站排名致关重要的影响因素是获得尽可能多的高质量外部链接，也称导入链接。网站即使没有向目录提交，但由于其他重要网站上有你的网站链接，一样可以获得搜索引擎的快速抓取，并为取得好排名加分。 
 
将导入链接纳入排名重要指标的依据在于，搜索引擎认为，如果你的网站富有价值，其它网站会提及你；对你提及越多，说明价值越大。由此引申出链接广度（Link Popularity）在搜索引擎优化中的重要地位。 
 
唯其如此，人们想方设法地为网站“制造”外部链接，导致涌出大量垃圾（spam）链接和网站，于是搜索引擎在算法调整中，仅对高质量的外部链接给予重视，对类似Spam的做法往往给予适得其反的结果。 
 
因此，今天对链接广度要有这样的认识：即使获得上百个质量低劣的或内容毫不相干的站点的链接，也抵不上一个高质量且内容高度相关或互补的站点的链接。

           声明：本博客为原创博客，未经允许，不得转载！原文链接为 http://blog.csdn.net/bettarwang/article/details/27012421。
 
      我们都知道，非静态内部类可以访问外部类的私有成员（包括私有变量和方法），这也正是使用非静态内部类与普通类的一个重要区别：非静态内部类是依赖于外部类对象而存在的，这种依赖就包括它要能自由地访问外部类对象的所有成员（因为private成员都可以访问了，其他权限的成员更不在话下。不过一般来说一个内部类只会访问外部类的部分成员而不是全部）。比如心脏作为单独的一个类存在可能没有太大的意义，它必须依附于具体的Person对象存在才有意义，而且心脏它要能够自由地访问Person对象的一些成员，如血液、营养等。
 
       显然，外部类对于非静态内部类而言是完全透明的。但是实际上，外部类与非静态内部类的另一个特征虽然不常用，却也值得注意，那就是非静态内部类其实跟外部类的其他成员类似，只是它的一个成员而已，因而即使非静态内部类的修饰符为private、即使非静态内部类的构造器修饰符为private，外部类也可以新建非静态内部类的对象。如下例所示：
 
 
import java.util.*;

class Car
{
  private float gasAmount;
  private String gasType;
  public Car(float gasAmount,String gasType)
  {
    this.gasAmount=gasAmount;
    this.gasType=gasType;
    new Engine();
  }

  private void print(String msg)
  {
     System.out.println(msg);
   }
  private class Engine
  {
    private int rotateSpeed;
    private Engine()
    {
      if(gasType=="93#"&&gasAmount>0)
      {
          rotateSpeed=1500;
          print("Gas amount is "+String.valueOf(gasAmount)+" gallon now.Engine starts successfully");
      }
      else if(gasType=="93#"&&gasAmount<=0)
      {
          rotateSpeed=0;
          print("Engine starts failed! Please add fuel first!");
       }
      else
      {
          rotateSpeed=0;
          print("Gas type is not correct!");
       }
      
    }
  }
}


public class OuterSample
{
  public static void main(String[]args)
  {
     new Car(2.0f,"93#");
     new Car(0.0f,"93#");
  }
}
 
 
输出结果如下图所示：
 

 
 
显然，由输出结果可看出：第一，虽然非静态内部类的修饰符和构造器均为private，但是外部类仍然可以创建内部类对象；第二，非静态内部类可以使用外部类的private成员（如此处的private成员变量gasType及gasAmount); 
 
       另一个常常被人忽略的地方是：在外部类的方法中，也可以通过创建非静态内部类的对象来访问内部类包括private成员在内的所有成员，不过注意必须是外部类的实例成员才行，而不能在外部类的静态成员（包括静态方法和静态初始化块）中使用非静态内部类，原因很简单：非静态内部类可看作是外部类的一个实例成员，而静态成员不能访问实例成员。如下例所示：
 
 
import java.util.*;

class Car
{
  private float gasAmount;
  private String gasType;
  private Engine engine;
  public Car(float gasAmount,String gasType)
  {
    this.gasAmount=gasAmount;
    this.gasType=gasType;
    engine=new Engine();
  }

  public void printRotateSpeed()
  {
    //其实写成print("Rotate speed is "+String.valueOf(new Engine().rotateSpeed));也行，但是不太符合实际，因为一车对应一引擎
     print("Rotate speed is "+String.valueOf(engine.rotateSpeed));
   }
  private void print(String msg)
  {
     System.out.println(msg);
   }
  private class Engine
  {
    private int rotateSpeed;
    private Engine()
    {
      if(gasType=="93#"&&gasAmount>0)
      {
          rotateSpeed=1500;
          print("Gas amount is "+String.valueOf(gasAmount)+" gallon now.Engine starts successfully");
      }
      else if(gasType=="93#"&&gasAmount<=0)
      {
          rotateSpeed=0;
          print("Engine starts failed! Please add fuel first!");
       }
      else
      {
          rotateSpeed=0;
          print("Gas type is not correct!");
       }
      
    }
  }
}


public class OuterSample
{
  public static void main(String[]args)
  {
     Car car01=new Car(2.0f,"93#");
     car01.printRotateSpeed();
     Car car02=new Car(0.0f,"93#");
     car02.printRotateSpeed();
  }
}
输出结果如下图： 
 

        从输出结果可以看出，在外部类的方法printRotateSpeed()中，通过非静态内部类的对象来a访问了其private成员rotateSpeed,这其实跟实际中的情况很像，即发动机从汽车处获得燃料信息，汽车再从发动机处获得转速并显示在仪表盘上。
 
      综上，非静态内部类可自由访问外部类包括privated成员在内的所有成员，外部类也可通过创建内部类的对象来访问其包括private成员在内的所有成员，所以它们虽然在类层面不是相互可见的，但是从广义上来说具有相互可见性，这也是我在题目上打上双引号的原因。

 内存碎片的产生：
 
         内存分配有静态分配和动态分配两种
        静态分配在程序编译链接时分配的大小和使用寿命就已经确定，而应用上要求操作系统可以提供给进程运行时申请和释放任意大小内存的功能，这就是内存的动态分配。
         因此动态分配将不可避免会产生内存碎片的问题，那么什么是内存碎片？内存碎片即“碎片的内存”描述一个系统中所有不可用的空闲内存，这些碎片之所以不能被使用，是因为负责动态分配内存的分配算法使得这些空闲的内存无法使用，这一问题的发生，原因在于这些空闲内存以小且不连续方式出现在不同的位置。因此这个问题的或大或小取决于内存管理算法的实现上。
 
        为什么会产生这些小且不连续的空闲内存碎片呢？
 
        实际上这些空闲内存碎片存在的方式有两种：a.内部碎片 b.外部碎片 。
        内部碎片的产生：因为所有的内存分配必须起始于可被 4、8 或 16 整除（视处理器体系结构而定）的地址或者因为MMU的分页机制的限制，决定内存分配算法仅能把预定大小的内存块分配给客户。假设当某个客户请求一个 43 字节的内存块时，因为没有适合大小的内存，所以它可能会获得 44字节、48字节等稍大一点的字节，因此由所需大小四舍五入而产生的多余空间就叫内部碎片。
       外部碎片的产生： 频繁的分配与回收物理页面会导致大量的、连续且小的页面块夹杂在已分配的页面中间，就会产生外部碎片。假设有一块一共有100个单位的连续空闲内存空间，范围是0~99。如果你从中申请一块内存，如10个单位，那么申请出来的内存块就为0~9区间。这时候你继续申请一块内存，比如说5个单位大，第二块得到的内存块就应该为10~14区间。如果你把第一块内存块释放，然后再申请一块大于10个单位的内存块，比如说20个单位。因为刚被释放的内存块不能满足新的请求，所以只能从15开始分配出20个单位的内存块。现在整个内存空间的状态是0~9空闲，10~14被占用，15~24被占用，25~99空闲。其中0~9就是一个内存碎片了。如果10~14一直被占用，而以后申请的空间都大于10个单位，那么0~9就永远用不上了，变成外部碎片。
 
 
  
 
 如何解决内存碎片：
 
         采用Slab Allocation机制：整理内存以便重复使用
         最近的memcached默认情况下采用了名为Slab Allocator的机制分配、管理内存。在该机制出现以前，内存的分配是通过对所有记录简单地进行malloc和free来进行的。但是，这种方式会导致内存碎片，加重操作系统内存管理器的负担，最坏的情况下，会导致操作系统比memcached进程本身还慢。Slab Allocator就是为解决该问题而诞生的。
         下面来看看Slab Allocator的原理。下面是memcached文档中的slab allocator的目标：he primary goal of the slabs subsystem in memcached was to eliminate memory fragmentation issuestotally by using fixedsizememory chunks coming from a few predetermined size classes.
         也就是说，Slab Allocator的基本原理是按照预先规定的大小，将分配的内存分割成特定长度的块，以完全解决内存碎片问题。Slab Allocation的原理相当简单。将分配的内存分割成各种尺寸的块（chunk），并把尺寸相同的块分成组（chunk的集合）（图2.1）。
 
 
 
   slab allocator还有重复使用已分配的内存的目的。也就是说，分配到的内存不会释放，而是重复利用
 
 Slab Allocation的主要术语
     Page
     分配给Slab的内存空间，默认是1MB。分配给Slab之后根据slab的大小切分成chunk。
     Chunk
     用于缓存记录的内存空间。
     Slab Class
     特定大小的chunk的组。
 
 在Slab中缓存记录的原理
 下面说明memcached如何针对客户端发送的数据选择slab并缓存到chunk中。memcached根据收到的数据的大小，选择最适合数据大小的slab（图2.2）。memcached中保存着slab内空闲chunk的列表，根据该列表选择chunk，然后将数据缓存于其中。
 
 
 
  
 图2.2：选择存储记录的组的方法
 实际上，Slab Allocator也是有利也有弊。下面介绍一下它的缺点。
 
 Slab Allocator的缺点
 Slab Allocator解决了当初的内存碎片问题，但新的机制也给memcached带来了新的问题。这个问题就是，由于分配的是特定长度的内存，因此无法有效利用分配的内存。例如，将100字节的数据缓存到128字节的chunk中，剩余的28字节就浪费了
 
 
 
  对于该问题目前还没有完美的解决方案，但在文档中记载了比较有效的解决方案。
 The most efficient way to reduce the waste is to use a list of size classes that closely matches (if that's at all
 possible) common sizes of objects that the clients of this particular installation of memcached are likely to
 store.
        就是说，如果预先知道客户端发送的数据的公用大小，或者仅缓存大小相同的数据的情况下，只要使用适合数据大小的组的列表，就可以减少浪费。但是很遗憾，现在还不能进行任何调优，只能期待以后的版本了。但是，我们可以调节slab class的大小的差别
 
  
 
 最佳适合与最差适合分配程序
 　　最佳适合算法在功能上与最先适合算法类似，不同之处是，系统在分配一个内存块时，要搜索整个自由表，寻找最接近请求存储量的内存块。这种搜索所花的时间要比最先适合算法长得多，但不存在分配大小内存块所需时间的差异。最佳适合算法产生的内存碎片要比最先适合算法多，因为将小而不能使用的碎片放在自由表开头部分的排序趋势更为强烈。由于这一消极因素，最佳适合算法几乎从来没有人采用过。
 　　最差适合算法也很少采用。最差适合算法的功能与最佳适合算法相同，不同之处是，当分配一个内存块时，系统在整个自由表中搜索与请求存储量不匹配的内存快。这种方法比最佳适合算法速度快，因为它产生微小而又不能使用的内存碎片的倾向较弱。始终选择最大空闲内存块，再将其分为小内存块，这样就能提高剩余部分大得足以供系统使用的概率。
 　　伙伴(buddy)分配程序与本文描述的其它分配程序不同，它不能根据需要从被管理内存的开头部分创建新内存。它有明确的共性，就是各个内存块可分可合，但不是任意的分与合。每个块都有个朋友，或叫“伙伴”，既可与之分开，又可与之结合。伙伴分配程序把内存块存放在比链接表更先进的数据结构中。这些结构常常是桶型、树型和堆型的组合或变种。一般来说，伙伴分配程序的工作方式是难以描述的，因为这种技术随所选数据结构的不同而各异。由于有各种各样的具有已知特性的数据结构可供使用，所以伙伴分配程序得到广泛应用。有些伙伴分配程序甚至用在源码中。伙伴分配程序编写起来常常很复杂，其性能可能各不相同。伙伴分配程序通常在某种程度上限制内存碎片。
 　　固定存储量分配程序有点像最先空闲算法。通常有一个以上的自由表，而且更重要的是，同一自由表中的所有内存块的存储量都相同。至少有四个指针：MSTART指向被管理内存的起点，MEND 指向被管理内存的末端，MBREAK 指向 MSTART 与 MEND 之间已用内存的末端，而 PFREE[n]则是指向任何空闲内存块的一排指针。在开始时，PFREE 为 NULL，MBREAK 指针为MSTART。当一个分配请求到来时，系统将请求的存储量增加到可用存储量之一。然后，系统检查 PFREE[ 增大后的存储量 ] 空闲内存块。因为PFREE[ 增大后的存储量 ] 为 NULL，一个具有该存储量加上一个管理标题的内存块就脱离 MBREAK，MBREAK 被更新。
 　　这些步骤反复进行，直至系统使一个内存块空闲为止，此时管理标题包含有该内存块的存储量。当有一内存块空闲时，PFREE[ 相应存储量 ]通过标题的链接表插入项更新为指向该内存块，而该内存块本身则用一个指向 PFREE[ 相应存储量 ]以前内容的指针来更新，以建立一个链接表。下一次分配请求到来时，系统将 PFREE[ 增大的请求存储量 ]链接表的第一个内存块送给系统。没有理由搜索链接表，因为所有链接的内存块的存储量都是相同的。
 　　固定存储量分配程序很容易实现，而且便于计算内存碎片，至少在块存储量的数量较少时是这样。但这种分配程序的局限性在于要有一个它可以分配的最大存储量。固定存储量分配程序速度快，并可在任何状况下保持速度。这些分配程序可能会产生大量的内部内存碎片，但对某些系统而言，它们的优点会超过缺点。
 
 　　减少内存碎片
 　　内存碎片是因为在分配一个内存块后，使之空闲，但不将空闲内存归还给最大内存块而产生的。最后这一步很关键。如果内存分配程序是有效的，就不能阻止系统分配内存块并使之空闲。即使一个内存分配程序不能保证返回的内存能与最大内存块相连接（这种方法可以彻底避免内存碎片问题），但你可以设法控制并限制内存碎片。所有这些作法涉及到内存块的分割。每当系统减少被分割内存块的数量，确保被分割内存块尽可能大时，你就会有所改进。
 　　这样做的目的是尽可能多次反复使用内存块，而不要每次都对内存块进行分割，以正好符合请求的存储量。分割内存块会产生大量的小内存碎片，犹如一堆散沙。以后很难把这些散沙与其余内存结合起来。比较好的办法是让每个内存块中都留有一些未用的字节。留有多少字节应看系统要在多大
 程度上避免内存碎片。对小型系统来说，增加几个字节的内部碎片是朝正确方向迈出的一步。当系统请求1字节内存时，你分配的存储量取决于系统的工作状态。
 　　如果系统分配的内存存储量的主要部分是 1 ～ 16 字节，则为小内存也分配 16字节是明智的。只要限制可以分配的最大内存块，你就能够获得较大的节约效果。但是，这种方法的缺点是，系统会不断地尝试分配大于极限的内存块，这使系统可能会停止工作。减少最大和最小内存块存储量之间内存存储量的数量也是有用的。采用按对数增大的内存块存储量可以避免大量的碎片。例如，每个存储量可能都比前一个存储量大20%。在嵌入式系统中采用“一种存储量符合所有需要”对于嵌入式系统中的内存分配程序来说可能是不切实际的。这种方法从内部碎片来看是代价极高的，但系统可以彻底避免外部碎片，达到支持的最大存储量。
 　　将相邻空闲内存块连接起来是一种可以显著减少内存碎片的技术。如果没有这一方法，某些分配算法（如最先适合算法）将根本无法工作。然而，效果是有限的，将邻近内存块连接起来只能缓解由于分配算法引起的问题，而无法解决根本问题。而且，当内存块存储量有限时，相邻内存块连接可能很难实现。
 　　有些内存分配器很先进，可以在运行时收集有关某个系统的分配习惯的统计数据，然后，按存储量将所有的内存分配进行分类，例如分为小、中和大三类。系统将每次分配指向被管理内存的一个区域，因为该区域包括这样的内存块存储量。较小存储量是根据较大存储量分配的。这种方案是最先适合算法和一组有限的固定存储量算法的一种有趣的混合，但不是实时的。
 　　有效地利用暂时的局限性通常是很困难的，但值得一提的是，在内存中暂时扩展共处一地的分配程序更容易产生内存碎片。尽管其它技术可以减轻这一问题，但限制不同存储量内存块的数目仍是减少内存碎片的主要方法。
 　　现代软件环境业已实现各种避免内存碎片的工具。例如，专为分布式高可用性容错系统开发的 OSE 实时操作系统可提供三种运行时内存分配程序：内核alloc()，它根据系统或内存块池来分配；堆 malloc()，根据程序堆来分配； OSE 内存管理程序alloc_region，它根据内存管理程序内存来分配。
 　　从许多方面来看，Alloc就是终极内存分配程序。它产生的内存碎片很少，速度很快，并有判定功能。你可以调整甚至去掉内存碎片。只是在分配一个存储量后，使之空闲，但不再分配时，才会产生外部碎片。内部碎片会不断产生，但对某个给定的系统和八种存储量来说是恒定不变的。
 　　Alloc是一种有八个自由表的固定存储量内存分配程序的实现方法。系统程序员可以对每一种存储量进行配置，并可决定采用更少的存储量来进一步减少碎片。除开始时以外，分配内存块和使内存块空闲都是恒定时间操作。首先，系统必须对请求的存储量四舍五入到下一个可用存储量。就八种存储量而言，这一目标可用三个 如果语句来实现。其次，系统总是在八个自由表的表头插入或删除内存块。开始时，分配未使用的内存要多花几个周期的时间，但速度仍然极快，而且所花时间恒定不变。
 　　堆 malloc() 的内存开销（8 ～ 16 字节/分配）比 alloc小，所以你可以停用内存的专用权。malloc()分配程序平均来讲是相当快的。它的内部碎片比alloc()少，但外部碎片则比alloc()多。它有一个最大分配存储量，但对大多数系统来说，这一极限值足够大。可选的共享所有权与低开销使 malloc() 适用于有许多小型对象和共享对象的 C++应用程序。堆是一种具有内部堆数据结构的伙伴系统的实现方法。在 OSE 中，有 28 个不同的存储量可供使用，每种存储量都是前两种存储量之和，于是形成一个斐波那契（Fibonacci）序列。实际内存块存储量为序列数乘以 16 字节，其中包括分配程序开销或者 8 字节/分配（在文件和行信息启用的情况下为 16 字节）。
 　　当你很少需要大块内存时，则OSE内存管理程序最适用。典型的系统要把存储空间分配给整个系统、堆或库。在有 MMU 的系统中，有些实现方法使用 MMU 的转换功能来显著降低甚至消除内存碎片。在其他情况下，OSE 内存管理程序会产生非常多的碎片。它没有最大分配存储量，而且是一种最先适合内存分配程序的实现方法。内存分配被四舍五入到页面的偶数——典型值是 4 k 字节。