本文主要介绍内存的基本概念以及操作系统的内存管理算法。
一、内存的基本概念
内存是计算机系统中除了处理器以外最重要的资源，用于存储当前正在执行的程序和数据。内存是相对于 CPU 来说的，CPU 可以直接寻址的存储空间叫做内存，CPU 需要通过驱动才能访问的叫做外存。
二、ROM&RAM&Flash
内存一般采用半导体存储单元，分为只读存储器(ROM，Read Only Memory)、随机存储器(RAM，Random Access Memory)ROM 一般只能读取不能写入，掉电后其中的数据也不会丢失。RAM 既可以从中读取也可以写入，但是掉电后其中的数据会丢失。内存一般指的就是 RAM。
ROM 在嵌入式系统中一般用于存储 BootLoader 以及操作系统或者程序代码或者直接当硬盘使用。近年来闪存(Flash)已经全面代替了 ROM 在嵌入式系统中的地位，它结合了 ROM 和 RAM 的长处，不仅具备电子可擦除可编程的特性，而且断电也不会丢失数据，同时可以快速读取数据。
三、两类内存管理方式 内存管理模块管理系统的内存资源，它是操作系统的核心模块之一。主要包括内存的初始化、分配以及释放。
从分配内存是否连续，可以分为两大类。
连续内存管理
为进程分配的内存空间是连续的，但这种分配方式容易形成内存碎片(碎片是难以利用的空闲内存，通常是小内存)，降低内存利用率。连续内存管理主要分为单一连续内存管理和分区式内存管理两种。
非连续内存管理
将进程分散到多个不连续的内存空间中，可以减少内存碎片，内存使用率更高。如果分配的基本单位是页，则称为分页内存管理；如果基本单位是段，则称为分段内存管理。
当前的操作系统，普遍采用非连续内存管理方式。不过因为分配粒度较大，对于内存较小的嵌入式系统，一般采用连续内存管理。本文主要对嵌入式系统中常用的连续内存管理的分区式内存管理进行介绍。
四、分区式内存管理 分区式内存管理分为固定分区和动态分区。
固定分区
事先就把内存划分为若干个固定大小的区域。分区大小既可以相等也可以不等。固定分区易于实现，但是会造成分区内碎片浪费，而且分区总数固定，限制了可以并发执行的进程数量。
动态分区
根据进程的实际需要，动态地给进程分配所需内存。
五、动态分区内存管理 运作机制
动态分区管理一般采用空闲链表法，即基于一个双向链表来保存空闲分区。对于初始状态，整个内存块都会被作为一个大的空闲分区加入到空闲链表中。当进程申请内存时，将会从这个空闲链表中找到一个大小满足要求的空闲分区。如果分区大于所需内存，则从该分区中拆分出需求大小的内存交给进程，并将此拆分出的内存从空闲链表中移除，剩下的内存仍然是一个挂在空闲链表中的空闲分区。
数据结构
空闲链表法有多种数据结构实现，这里介绍一种较为简单的数据结构。每个空闲分区的数据结构中包含分区的大小，以及指向前一个分区和后一个分区的指针，这样就能将各个空闲分区链接成一个双向链表。
内存分配算法
First Fit(首次适应算法)
First Fit 要求空闲分区链表以地址从小到大的顺序链接。分配内存时，从链表的第一个空闲分区开始查找，将最先能够满足要求的空闲分区分配给进程。
Next Fit(循环首次适应算法)
Next Fit 由 First Fit 算法演变而来。分配内存时，从上一次刚分配过的空闲分区的下一个开始查找，直至找到能满足要求的空闲分区。查找时会采用循环查找的方式，即如果直到链表最后一个空闲分区都不能满足要求，则返回到第一个空闲分区开始查找。
Best Fit(最佳适应算法)
从所有空闲分区中找出能满足要求的、且大小最小的空闲分区。为了加快查找速度，Best Fit 算法会把所有空闲分区按其容量从小到大的顺序链接起来，这样第一次找到的满足大小要求的内存必然是最小的空闲分区。
Worst Fit(最坏适应算法)
从所有空闲分区中找出能满足要求的、且大小最大的空闲分区。Worst Fit 算法按其容量从大到小的顺序链接所有空闲分区。
Two LevelSegregated Fit(TLSF)
使用两层链表来管理空闲内存，将空闲分区大小进行分类，每一类用一个空闲链表表示，其中的空闲内存大小都在某个特定值或者某个范围内。这样存在多个空闲链表，所以又用一个索引链表来管理这些空闲链表，该表的每一项都对应一种空闲链表，并记录该类空闲链表的表头指针。
图中，第一层链表将空闲内存块的大小根据 2 的幂进行分类。第二层链表是具体的每一类空闲内存块按照一定的范围进行线性分段。比如 25 这一类，以 23 即 8 分为 4 个内存区间【25，25+8)，【25+8，25+16)，【25+16，25+24)，【25+24，25+32)；216 这一类，以 214 分为 4 个小区间【216，216+214)，【216+214，216+2*214)，【216+2*214，216+3*214)，【216+3*214，216+4*214)。同时为了快速检索到空闲块，每一层链表都有一个 bitmap 用于标记对应的链表中是否有空闲块，比如第一层 bitmap 后 3 位 010，表示 25 这一类内存区间有空闲块。对应的第二层 bitmap 为 0100 表示【25+16，25+24)这个区间有空闲块，即下面的 52Byte。
Buddysystems(伙伴算法)
Segregated Fit 算法的变种，具有更好的内存拆分和回收合并效率。伙伴算法有很多种类，比如 BinaryBuddies，Fibonacci Buddies 等。Binary Buddies 是最简单也是最流行的一种，将所有空闲分区根据分区的大小进行分类，每一类都是具有相同大小的空闲分区的集合，使用一个空闲双向链表表示。BinaryBuddies 中所有的内存分区都是 2 的幂次方。 因为无论是已分配的或是空闲的分区，其大小均为 2 的幂次方，即使进程申请的内存小于分配给它的内存块，多余的内存也不会再拆分出来给其他进程使用，这样就容易造成内部碎片。 当进程申请一块大小为 n 的内存时的分配步骤为：
1、计算一个 i 值，使得 2i-1
2、在空闲分区大小为 2i 的空闲链表中查找
3、如果找到空闲块，则分配给进程
4、如果 2i 的空闲分区已经耗尽，则在分区大小为 2i+1 的空闲链表中查找
5、如果存在 2i+1 的空闲分区，则将此空闲块分为相等的两个分区，这两分区就是一对伙伴，其中一块分配给进程，另一块挂到分区大小为 2i 的空闲链表中
6、如果 2i+1 的空闲分区还是不存在，则继续查找大小为 2i+2 的空闲分区。如果找到，需要进行两次拆分。第一次拆分为两块大小为 2i+1 的分区，一块分区挂到大小为 2i+1 的空闲链表中，另一块分区继续拆分为两块大小为 2i 的空闲分区，一块分配给进程，另一块挂到大小为 2i 的空闲链表中
7、如果 2i+2 的空闲分区也找不到，则继续查找 2i+3，以此类推
在内存回收时，如果待回收的内存块与空闲链表中的一块内存互为伙伴，则将它们合并为一块更大的内存块，如果合并后的内存块在空闲链表中还有伙伴，则继续合并到不能合并为止，并将合并后的内存块挂到对应的空闲链表中。
下面的表格对上面 6 种算法的优缺点进行了比较：

                    

                    

                    
                    
                    
关注、星标公众号，不错过精彩内容
转自：LiteOS物联网操作系统
本文主要介绍内存的基本概念以及操作系统的内存管理算法。
一、内存的基本概念
内存是计算机系统中除了处理器以外最重要的资源，用于存储当前正在执行的程序和数据。内存是相对于CPU来说的，CPU可以直接寻址的存储空间叫做内存，CPU需要通过驱动才能访问的叫做外存。
二、ROM&RAM&Flash
内存一般采用半导体存储单元，分为只读存储器（ROM，Read Only Memory）、随机存储器（RAM，Random Access Memory）ROM一般只能读取不能写入，掉电后其中的数据也不会丢失。RAM既可以从中读取也可以写入，但是掉电后其中的数据会丢失。内存一般指的就是RAM。
ROM在嵌入式系统中一般用于存储BootLoader以及操作系统或者程序代码或者直接当硬盘使用。近年来闪存（Flash）已经全面代替了ROM在嵌入式系统中的地位，它结合了ROM和RAM的长处，不仅具备电子可擦除可编程的特性，而且断电也不会丢失数据，同时可以快速读取数据。
三、两类内存管理方式
内存管理模块管理系统的内存资源，它是操作系统的核心模块之一。主要包括内存的初始化、分配以及释放。
从分配内存是否连续，可以分为两大类。
连续内存管理
为进程分配的内存空间是连续的，但这种分配方式容易形成内存碎片（碎片是难以利用的空闲内存，通常是小内存），降低内存利用率。连续内存管理主要分为单一连续内存管理和分区式内存管理两种。
非连续内存管理
将进程分散到多个不连续的内存空间中，可以减少内存碎片，内存使用率更高。如果分配的基本单位是页，则称为分页内存管理；如果基本单位是段，则称为分段内存管理。
当前的操作系统，普遍采用非连续内存管理方式。不过因为分配粒度较大，对于内存较小的嵌入式系统，一般采用连续内存管理。本文主要对嵌入式系统中常用的连续内存管理的分区式内存管理进行介绍。
四、分区式内存管理
分区式内存管理分为固定分区和动态分区。
固定分区
事先就把内存划分为若干个固定大小的区域。分区大小既可以相等也可以不等。固定分区易于实现，但是会造成分区内碎片浪费，而且分区总数固定，限制了可以并发执行的进程数量。
动态分区
根据进程的实际需要，动态地给进程分配所需内存。
五、动态分区内存管理
运作机制
动态分区管理一般采用空闲链表法，即基于一个双向链表来保存空闲分区。对于初始状态，整个内存块都会被作为一个大的空闲分区加入到空闲链表中。当进程申请内存时，将会从这个空闲链表中找到一个大小满足要求的空闲分区。如果分区大于所需内存，则从该分区中拆分出需求大小的内存交给进程，并将此拆分出的内存从空闲链表中移除，剩下的内存仍然是一个挂在空闲链表中的空闲分区。
数据结构
空闲链表法有多种数据结构实现，这里介绍一种较为简单的数据结构。每个空闲分区的数据结构中包含分区的大小，以及指向前一个分区和后一个分区的指针，这样就能将各个空闲分区链接成一个双向链表。
内存分配算法
First Fit（首次适应算法）
First Fit要求空闲分区链表以地址从小到大的顺序链接。分配内存时，从链表的第一个空闲分区开始查找，将最先能够满足要求的空闲分区分配给进程。
Next Fit（循环首次适应算法）
Next Fit由First Fit算法演变而来。分配内存时，从上一次刚分配过的空闲分区的下一个开始查找，直至找到能满足要求的空闲分区。查找时会采用循环查找的方式，即如果直到链表最后一个空闲分区都不能满足要求，则返回到第一个空闲分区开始查找。
Best Fit（最佳适应算法）
从所有空闲分区中找出能满足要求的、且大小最小的空闲分区。为了加快查找速度，Best Fit算法会把所有空闲分区按其容量从小到大的顺序链接起来，这样第一次找到的满足大小要求的内存必然是最小的空闲分区。
Worst Fit（最坏适应算法）
从所有空闲分区中找出能满足要求的、且大小最大的空闲分区。Worst Fit算法按其容量从大到小的顺序链接所有空闲分区。
Two LevelSegregated Fit（TLSF）
使用两层链表来管理空闲内存，将空闲分区大小进行分类，每一类用一个空闲链表表示，其中的空闲内存大小都在某个特定值或者某个范围内。这样存在多个空闲链表，所以又用一个索引链表来管理这些空闲链表，该表的每一项都对应一种空闲链表，并记录该类空闲链表的表头指针。
图中，第一层链表将空闲内存块的大小根据2的幂进行分类。第二层链表是具体的每一类空闲内存块按照一定的范围进行线性分段。比如25这一类，以23即8分为4个内存区间【25，25+8），【25+8，25+16），【25+16，25+24），【25+24，25+32）；216这一类，以214分为4个小区间【216，216+214），【216+214，216+2*214），【216+2*214，216+3*214），【216+3*214，216+4*214）。同时为了快速检索到空闲块，每一层链表都有一个bitmap用于标记对应的链表中是否有空闲块，比如第一层bitmap后3位010，表示25这一类内存区间有空闲块。对应的第二层bitmap为0100表示【25+16，25+24）这个区间有空闲块，即下面的52Byte。
Buddysystems（伙伴算法）
Segregated Fit算法的变种，具有更好的内存拆分和回收合并效率。伙伴算法有很多种类，比如BinaryBuddies，Fibonacci Buddies等。Binary Buddies是最简单也是最流行的一种，将所有空闲分区根据分区的大小进行分类，每一类都是具有相同大小的空闲分区的集合，使用一个空闲双向链表表示。BinaryBuddies中所有的内存分区都是2的幂次方。
因为无论是已分配的或是空闲的分区，其大小均为 2 的幂次方，即使进程申请的内存小于分配给它的内存块，多余的内存也不会再拆分出来给其他进程使用，这样就容易造成内部碎片。
当进程申请一块大小为n的内存时的分配步骤为：
1、计算一个i值，使得2i-1<n≤2i
2、在空闲分区大小为2i的空闲链表中查找
3、如果找到空闲块，则分配给进程
4、如果2i的空闲分区已经耗尽，则在分区大小为2i+1的空闲链表中查找
5、如果存在2i+1的空闲分区，则将此空闲块分为相等的两个分区，这两分区就是一对伙伴，其中一块分配给进程，另一块挂到分区大小为2i的空闲链表中
6、如果2i+1的空闲分区还是不存在，则继续查找大小为2i+2的空闲分区。如果找到，需要进行两次拆分。第一次拆分为两块大小为2i+1的分区，一块分区挂到大小为2i+1的空闲链表中，另一块分区继续拆分为两块大小为2i的空闲分区，一块分配给进程，另一块挂到大小为2i的空闲链表中
7、如果2i+2的空闲分区也找不到，则继续查找2i+3，以此类推
在内存回收时，如果待回收的内存块与空闲链表中的一块内存互为伙伴，则将它们合并为一块更大的内存块，如果合并后的内存块在空闲链表中还有伙伴，则继续合并到不能合并为止，并将合并后的内存块挂到对应的空闲链表中。
下面的表格对上面6种算法的优缺点进行了比较：
内存算法
优点
缺点
First Fit
高地址空间大空闲块被保留
低地址空间被不断拆分，造成碎片；每次都从第一个空闲分区开始查找，增加了查找时的系统开销
Next Fit
空闲分区分布比较均匀，算法开销小
缺乏大内存空闲块
Best Fit
用最小内存满足要求，保留大内存空闲块
每次分配后所拆分出来的剩余空闲内存总是最小的，造成许多小碎片，算法开销大
Worst Fit
每次分配后所拆分出来的剩余空闲内存仍较大，减少小碎片产生
缺乏大内存空闲块，算法开销大
TLSF
查找效率高，时间复杂度小，碎片问题表现良好
内存回收时算法复杂，系统开销大
Buddy systems
内部碎片比较严重
外部碎片较少
免责声明：本文转自LiteOS物联网操作系统，版权归原作者所有。如涉及作品版权问题，请与我联系删除。
推荐阅读：
ST-LINK Utility查看内核运行状态
C语言中几种特殊标准定义和用法
C语言 volatile 关键字在编译优化过程中有何作用
关注微信公众号『strongerHuang』，后台回复“1024”查看更多内容，回复“加群”按规则加入技术交流群。
长按前往图中包含的公众号关注
                

本文主要介绍内存的基本概念以及操作系统的内存管理算法。
一、内存的基本概念
内存是计算机系统中除了处理器以外最重要的资源，用于存储当前正在执行的程序和数据。内存是相对于 CPU 来说的，CPU 可以直接寻址的存储空间叫做内存，CPU 需要通过驱动才能访问的叫做外存。
二、ROM&RAM&Flash
内存一般采用半导体存储单元，分为只读存储器(ROM，Read Only Memory)、随机存储器(RAM，Random Access Memory)ROM 一般只能读取不能写入，掉电后其中的数据也不会丢失。RAM 既可以从中读取也可以写入，但是掉电后其中的数据会丢失。内存一般指的就是 RAM。
ROM 在嵌入式系统中一般用于存储 BootLoader 以及操作系统或者程序代码或者直接当硬盘使用。近年来闪存(Flash)已经全面代替了 ROM 在嵌入式系统中的地位，它结合了 ROM 和 RAM 的长处，不仅具备电子可擦除可编程的特性，而且断电也不会丢失数据，同时可以快速读取数据。
三、两类内存管理方式 内存管理模块管理系统的内存资源，它是操作系统的核心模块之一。主要包括内存的初始化、分配以及释放。
从分配内存是否连续，可以分为两大类。
连续内存管理
为进程分配的内存空间是连续的，但这种分配方式容易形成内存碎片(碎片是难以利用的空闲内存，通常是小内存)，降低内存利用率。连续内存管理主要分为单一连续内存管理和分区式内存管理两种。
非连续内存管理
将进程分散到多个不连续的内存空间中，可以减少内存碎片，内存使用率更高。如果分配的基本单位是页，则称为分页内存管理；如果基本单位是段，则称为分段内存管理。
当前的操作系统，普遍采用非连续内存管理方式。不过因为分配粒度较大，对于内存较小的嵌入式系统，一般采用连续内存管理。本文主要对嵌入式系统中常用的连续内存管理的分区式内存管理进行介绍。
四、分区式内存管理 分区式内存管理分为固定分区和动态分区。
固定分区
事先就把内存划分为若干个固定大小的区域。分区大小既可以相等也可以不等。固定分区易于实现，但是会造成分区内碎片浪费，而且分区总数固定，限制了可以并发执行的进程数量。
动态分区
根据进程的实际需要，动态地给进程分配所需内存。
五、动态分区内存管理 运作机制
动态分区管理一般采用空闲链表法，即基于一个双向链表来保存空闲分区。对于初始状态，整个内存块都会被作为一个大的空闲分区加入到空闲链表中。当进程申请内存时，将会从这个空闲链表中找到一个大小满足要求的空闲分区。如果分区大于所需内存，则从该分区中拆分出需求大小的内存交给进程，并将此拆分出的内存从空闲链表中移除，剩下的内存仍然是一个挂在空闲链表中的空闲分区。
数据结构
空闲链表法有多种数据结构实现，这里介绍一种较为简单的数据结构。每个空闲分区的数据结构中包含分区的大小，以及指向前一个分区和后一个分区的指针，这样就能将各个空闲分区链接成一个双向链表。
内存分配算法
First Fit(首次适应算法)
First Fit 要求空闲分区链表以地址从小到大的顺序链接。分配内存时，从链表的第一个空闲分区开始查找，将最先能够满足要求的空闲分区分配给进程。
Next Fit(循环首次适应算法)
Next Fit 由 First Fit 算法演变而来。分配内存时，从上一次刚分配过的空闲分区的下一个开始查找，直至找到能满足要求的空闲分区。查找时会采用循环查找的方式，即如果直到链表最后一个空闲分区都不能满足要求，则返回到第一个空闲分区开始查找。
Best Fit(最佳适应算法)
从所有空闲分区中找出能满足要求的、且大小最小的空闲分区。为了加快查找速度，Best Fit 算法会把所有空闲分区按其容量从小到大的顺序链接起来，这样第一次找到的满足大小要求的内存必然是最小的空闲分区。
Worst Fit(最坏适应算法)
从所有空闲分区中找出能满足要求的、且大小最大的空闲分区。Worst Fit 算法按其容量从大到小的顺序链接所有空闲分区。
Two LevelSegregated Fit(TLSF)
使用两层链表来管理空闲内存，将空闲分区大小进行分类，每一类用一个空闲链表表示，其中的空闲内存大小都在某个特定值或者某个范围内。这样存在多个空闲链表，所以又用一个索引链表来管理这些空闲链表，该表的每一项都对应一种空闲链表，并记录该类空闲链表的表头指针。
图中，第一层链表将空闲内存块的大小根据 2 的幂进行分类。第二层链表是具体的每一类空闲内存块按照一定的范围进行线性分段。比如 25 这一类，以 23 即 8 分为 4 个内存区间【25，25+8)，【25+8，25+16)，【25+16，25+24)，【25+24，25+32)；216 这一类，以 214 分为 4 个小区间【216，216+214)，【216+214，216+2*214)，【216+2*214，216+3*214)，【216+3*214，216+4*214)。同时为了快速检索到空闲块，每一层链表都有一个 bitmap 用于标记对应的链表中是否有空闲块，比如第一层 bitmap 后 3 位 010，表示 25 这一类内存区间有空闲块。对应的第二层 bitmap 为 0100 表示【25+16，25+24)这个区间有空闲块，即下面的 52Byte。
Buddysystems(伙伴算法)
Segregated Fit 算法的变种，具有更好的内存拆分和回收合并效率。伙伴算法有很多种类，比如 BinaryBuddies，Fibonacci Buddies 等。Binary Buddies 是最简单也是最流行的一种，将所有空闲分区根据分区的大小进行分类，每一类都是具有相同大小的空闲分区的集合，使用一个空闲双向链表表示。BinaryBuddies 中所有的内存分区都是 2 的幂次方。 因为无论是已分配的或是空闲的分区，其大小均为 2 的幂次方，即使进程申请的内存小于分配给它的内存块，多余的内存也不会再拆分出来给其他进程使用，这样就容易造成内部碎片。 当进程申请一块大小为 n 的内存时的分配步骤为：
1、计算一个 i 值，使得 2i-1
2、在空闲分区大小为 2i 的空闲链表中查找
3、如果找到空闲块，则分配给进程
4、如果 2i 的空闲分区已经耗尽，则在分区大小为 2i+1 的空闲链表中查找
5、如果存在 2i+1 的空闲分区，则将此空闲块分为相等的两个分区，这两分区就是一对伙伴，其中一块分配给进程，另一块挂到分区大小为 2i 的空闲链表中
6、如果 2i+1 的空闲分区还是不存在，则继续查找大小为 2i+2 的空闲分区。如果找到，需要进行两次拆分。第一次拆分为两块大小为 2i+1 的分区，一块分区挂到大小为 2i+1 的空闲链表中，另一块分区继续拆分为两块大小为 2i 的空闲分区，一块分配给进程，另一块挂到大小为 2i 的空闲链表中
7、如果 2i+2 的空闲分区也找不到，则继续查找 2i+3，以此类推
在内存回收时，如果待回收的内存块与空闲链表中的一块内存互为伙伴，则将它们合并为一块更大的内存块，如果合并后的内存块在空闲链表中还有伙伴，则继续合并到不能合并为止，并将合并后的内存块挂到对应的空闲链表中。
下面的表格对上面 6 种算法的优缺点进行了比较：

python的内存管理算法与优化
前期准备

我们可以用python的gc模块控制python的内存管理和回收

gc.disable()# 暂停自动垃圾回收
gc.collect()# 执行完整的垃圾回收，返回无法到达的对象的数量
gc.set_threshold()# 设置垃圾回收的阈值
gc.set_debug()# 设置垃圾回收的调试标记. 调试信息会被写入std.err.


sys跟objgraph库

python内存管理算法
python的内存管理机制有两种：引用计数和分代垃圾回收
引用次数

引用计数+1的情况

对象被创建 a=‘123’

对象被引用 b=a

对象被当作参数传入函数 fun（a）

对象最为元素存储到容器中 c={a:’1’}
引用计数-1的情况

对象的别名被显式销毁 del b

对象的别名被赋予其它值 b=1

对象离开它的作用域，比如函数执行完毕后，函数里面的局部变量的引用计数-1

对象从容器中删除，或者所在的容器被销毁  del c
引用计数的优点

高效

回收内存的时间是分布的，引用计数为0马上回收，不会给系统造成停顿

对象生命周期明确

容易实现
引用计数缺点

额外空间维护引用计数

无法解决循环引用的情况

循环引用的例子

a=[1]
b=[2]
a.append(b)
b.append(a)


del a
del b

#del a del b只是把引用计数-1，del后ab原来所指的对象的引用计数为1 无法进行资源回收，但也无法访问




查看引用计数的方法

sys.getrefcount()

objgraph.count()

垃圾回收机制
python的垃圾回收机制就是为了解决循环引用的问题

python的垃圾回收机制分为mark-sweep算法和分代（generational）算法

mark-sweep算法

分为mark（标记）和sweep（清除）两部分

python中所有能够引用其它对象的对象都叫做container（容器），只有container之间才会出现循环引用

把所有的容器都放到一个双向链表中，使用双向链表是为了方便快速插入删除对象

mark部分具体的操作如下

每个容器设置一个gc_ref，并初始化为该容器的引用计数值ob_ref
对每个容器，找到它引用的所有对象，将被引用对象的gc_ref-1
对所有容器执行完上述操作后，所有gc_ref不为0的容器则还存在被引用的情况，不能销毁，把他们放到另一个集合A
上一个操作中的集合A中，他们所引用的对象也是不能释放的，也放进集合A中
剩下的不在集合A里面的则可以进行回收

需要回收的内存就是存在循环引用的容器，循环引用的容器集合会成为一个孤岛，外部没有办法访问到，mark部分的原理其实就是模拟了一次容器自身的释放，这样就可以打破循环引用的容器集合中互相依赖的情况
sweep部分可以略过,就是对mark找出来的部分进行回收

分代（generational）算法

python根据容器的活跃程度把容器分为三代：0代、1代、2代，每一代都是一个由双向链表实现的容器集合

上述的mark-sweep算法其实并非每次都对所有容器都进行标记清除，而是每次对同一代的容器进行标记清除

给容器分代的原因—弱代假说

弱代假说的观点：年轻的对象更快销毁，年老的对象可能存活更长时间，比如局部变量跟全局变量的对比
如果不用分代算法，每次都对所有容器进行mark-sweep，实际上有一部分容器还没到达销毁时间，我们不希望这部分容器被频繁地执行算法，所以有了分代算法

分代算法的过程跟触发每一代的规则

每当容器被创建时，python把它加入0代链表中
0代：当被分配的对象的数量减去被释放对象后的差值大于设置的threshold0时，启动0代中的mark-sweep算法，产生的不被销毁的容器集合并入1代链表中
1代：当0代启动mark-sweep算法的次数大于设置的threshold1时，启动1代中的mark-sweep算法，产生的不被销毁的容器集合并入2代链表中
2代：当1代启动mark-sweep算法的次数大于设置的threshold2时，启动2代中的mark-sweep算法

通过gc.set_threshold()可以设置threshold0、threshold1、threshold2的值
python内存管理优化
每一次python进行垃圾回收，都要对所有的容器进行两次遍历（第一次设置gc_ref值，第二次让gc_ref-1）,所以消耗会很大，我们可以在程序层面进行一些调优
调优方式

手动垃圾回收


关闭自动回收gc.disable()
合适的时候用gc.collect()触发垃圾回收，比如打游戏过程中不进行垃圾回收，在用户等待或游戏结算的时候再出发垃圾回收



提高垃圾回收阈值

通过gc.set_threshold()设置回收阈值，减少垃圾回收的次数


避免循环引用

整个垃圾回收机制都是为了解决循环引用的问题，如果代码能保证没有循环引用问题，则可以直接关闭垃圾回收


常见手段

手动解循环引用

class A(object):
   def __init__(self):
       self.child = None


   def destroy(self):
       self.child = None


class B(object):
   def __init__(self):
       self.parent = None


   def destroy(self):
       self.parent = None


def test3():
   a = A()
   b = B()
   a.child = b
   b.parent = a
   a.destroy()
   b.destroy()


test3()
print 'Object count of A:', objgraph.count('A’) #0
print 'Object count of B:', objgraph.count('B’) #0




使用弱引用，python自带的弱引用库weakref 弱引用相关参考：https://yuerblog.cc/2018/08/28/python-weakref-real-usage/

def test4():
   a = A()
   b = B()
   a.child = weakref.ref(b)
   b.parent = weakref.ref(a)


test4()
print 'Object count of A:', objgraph.count('A’) #0
print 'Object count of B:', objgraph.count('B’) #0



内存泄露
有了引用计数和垃圾回收，python仍然有可能发生内存泄露，发生的情况如下

对象被另一个生命周期特别长的对象所引用，比如网络服务器，可能存在一个全局的单例ConnectionManager，管理所有的连接Connection，如果当Connection理论上不再被使用的时候，没有从ConnectionManager中删除，那么就造成了内存泄露。
循环引用的对象中定义了__del__函数，如果定义了这个函数，python无法判断析构对象的顺序，因此会不做处理

参考
http://www.doc88.com/p-78747715867.html

http://kkpattern.github.io/2015/06/20/python-memory-optimization-zh.html

https://blog.csdn.net/xiongchengluo1129/article/details/80462651

https://www.cnblogs.com/xybaby/p/7491656.html