（1）栈区#

• 变量名与值内存地址的关联关系通常被存放于程序的栈区

1
# 1. 栈区的特性与作用
2
   栈（Stack）是计算机内存中的一种数据结构，其主要特点是后进先出（LIFO）。在编程语言执行过程中，栈区用于存储局部变量、函数参数以及函数调用时的返回地址等临时性信息。栈区的操作快速且高效，因为它遵循简单的压栈（push）和弹栈（pop）规则，适合处理那些生命周期短、使用频繁且需要保持特定顺序的数据。
3

4
# 2. 变量生命周期管理
5
   变量名与值内存地址的关联关系本质上是一种符号表信息，它记录了源代码中定义的变量名与其所对应的内存地址之间的映射。这种信息具有明显的生命周期特征：当进入一个作用域（如函数或代码块）时，新声明的变量及其关联关系应被创建；当离开该作用域时，这些变量及关联关系应被自动清理以释放资源。栈区恰好符合这种对变量生命周期进行严格管理的需求。每当函数调用发生时，会在栈顶为该函数分配一块空间，用于存放其内部声明的变量及其关联关系；函数调用结束时，这部分栈空间会被自动回收。
6

7
# 3. 性能优化
8
   栈区访问速度极快，因为它的内存地址通常连续且靠近CPU寄存器。将变量名与值内存地址的关联关系放在栈上，可以确保编译器和运行时系统能以较低的时间成本查找并操作这些信息。特别是在递归调用、循环等频繁涉及变量访问的场景下，栈区的高效访问对于提升程序整体性能至关重要。
9

10
# 4. 内存安全性
11
   栈区的内存由编译器自动分配和释放，不易出现内存泄漏问题。将变量名与值内存地址的关联关系存储在栈上，有助于防止因程序员手动管理内存不当而导致的错误。此外，栈区的大小通常有限制，这有助于防止因局部变量过度使用内存而导致的堆栈溢出问题，从而提高程序稳定性。
12

13
# 5. 线程安全性
14
   每个线程都有自己的栈空间，这意味着不同线程中的同名局部变量各自拥有 ** 的内存地址和关联关系，互不影响。这一特性保证了并发环境下的数据安全，避免了线程间的数据混淆。
15

16
# 综上所述
17
    将变量名与值内存地址的关联关系存放于栈区，既利用了栈区的特性实现了高效的内存管理、快速访问和严格的生命周期控制，又确保了内存安全性与线程安全性，有利于编写稳定、高效且易于维护的程序代码。
18
  当然，需要注意的是，上述讨论主要针对局部变量。
19
  对于静态变量、全局变量或动态分配的对象，它们的内存地址关联关系可能存在于数据段（Data Segment）或堆区（Heap），而非栈区。

（2）堆区#

• 变量值存放于堆区，内存管理回收的则是堆区的内容

1
# 在Python中，变量和它们所引用的对象（如数值、字符串、列表、字典等）的存储位置与内存管理机制密切相关。
2
# 这里提到的“变量值存放于堆区”主要涉及两个概念：变量本身和它所引用的对象。
3

4
# 1. 变量
5
   变量是程序中用于标识数据的一个符号或名字，它并不直接存储数据，而是指向（或引用）实际存储数据的内存地址。
6
   在Python解释器内部，变量名通常保存在栈（Stack）中。栈是一种后进先出（LIFO）的数据结构，用于高效地管理函数调用时的局部变量、返回地址等信息。
7
   当创建一个变量时，Python会在当前作用域（如全局作用域或函数局部作用域）的栈空间内为该变量分配一个名称，并将其关联到相应的对象。
8

9
# 2. 对象及值
10
   Python中的对象（即变量所引用的实际数据）通常存储在堆（Heap）中。
11
   堆是一种动态分配内存的区域，相比于栈，其大小更为灵活且无固定上限。
12
   堆用于存储需要大量、不固定大小内存空间的数据结构，如大数组、复杂的数据类型（如类实例）、以及那些生命周期可能跨越多个函数调用或作用域的对象。
13

14
# 将对象值存放在堆区有以下几个原因：
15

16
# - 灵活性
17
    堆内存的大小可以动态调整，能够适应不同大小和复杂度的对象。
18
    这使得Python可以在运行时根据需要创建任意大小的对象，无需预先确定其具体尺寸，非常适合处理变长数据结构（如列表、字典）。
19

20
# - 共享性
21
    多个变量可以同时引用同一块堆内存中的对象，实现对象的共享。
22
    这种机制允许通过赋值、参数传递、返回值等方式高效地复制“引用”，而不是复制整个对象内容，节省了内存资源并提高了效率。
23

24
# - 垃圾回收
25
    由于堆内存中的对象可能存在多个引用，Python使用垃圾回收（Garbage Collection, GC）机制自动追踪和管理对象的生命周期。
26
    当一个对象不再有任何引用时，GC会识别并释放其占用的堆内存，防止内存泄漏。
27
    堆区便于实施这样的垃圾回收策略，确保程序长期运行时内存的有效利用。
28

29
# 综上所述
30
    Python将变量值（即对象）存放于堆区，主要是为了提供灵活的内存分配、支持对象共享以及实现自动化的垃圾回收，这些特性对于编写高效、健壮的Python程序至关重要。
31
    而变量本身作为对象的引用，则通常存储在栈区，便于快速访问和管理其生命周期。

（3）示例#

• 定义了两个变量x = 10、y = 20，详解如下图

• 当我们执行x=y时，内存中的栈区与堆区变化如下

（1）引用计数#

• 引用计数就是：变量值被变量名关联的次数
  • 如：age=18
• 变量值18被关联了一个变量名age，称之为引用计数为1

（2）引用计数增加#

• age=18 （此时，变量值18的引用计数为1）
• m=age （把age的内存地址给了m，此时，m,age都关联了18，所以变量值18的引用计数为2）

（3）引用计数减少#

• age=10（名字age先与值18解除关联，再与3建立了关联，变量值18的引用计数为1）
• del m（del的意思是解除变量名x与变量值18的关联关系，此时，变量18的引用计数为0）

• 值18的引用计数一旦变为0，其占用的内存地址就应该被解释器的垃圾回收机制回收

（4）小结#

• 一个变量值可以有多个变量名指向，有一个变量名指向，引用计数就是1，有两个就是2
• 只要引用计数不为0，这个变量值就不是垃圾数据，当引用计数为0了，说明这个变量值就没用了，就可以清除了

1
一个变量名只能指向一个内存空间： 意味着一个变量名在某一时刻只能代表一个值。当你给一个变量赋新值时，它将指向新的内存空间，不再指向之前的。
2

3
一个内存空间可以被多个变量名指向： 多个变量名可以同时指向相同的内存空间。这意味着如果你改变了这个内存空间的值，所有指向它的变量都会受到影响。

（5）引用计数的问题#

• 引用计数机制存在着一个致命的弱点，即循环引用（也称交叉引用）

1
# 如下我们定义了两个列表，简称列表1与列表2，变量名l1指向列表1，变量名l2指向列表2
2
l1 = ['xxx']  # 列表1被引用一次，列表1的引用计数变为1
3
l2 = ['yyy']  # 列表2被引用一次，列表2的引用计数变为1
4
l1.append(l2)  # 把列表2追加到l1中作为第二个元素，列表2的引用计数变为2
5
l2.append(l1)  # 把列表1追加到l2中作为第二个元素，列表1的引用计数变为2
6

7
# 1. l1与l2之间有相互引用
8
# 2. l1 = ['xxx'的内存地址,列表2的内存地址]
9
# 3. l2 = ['yyy'的内存地址,列表1的内存地址]
10

11
print(l1)  # ['xxx', ['yyy', [...]]]
12

13
print(l2)  # ['yyy', ['xxx', [...]]]

• 循环引用会导致：
  • 值不再被任何名字关联，但是值的引用计数并不会为0，应该被回收但不能被回收
• 什么意思呢？试想一下，请看如下操作

1
# 如下我们定义了两个列表，简称列表1与列表2，变量名l1指向列表1，变量名l2指向列表2
2
l1 = ['xxx']  # 列表1被引用一次，列表1的引用计数变为1
3
l2 = ['yyy']  # 列表2被引用一次，列表2的引用计数变为1
4
l1.append(l2)  # 把列表2追加到l1中作为第二个元素，列表2的引用计数变为2
5
l2.append(l1)  # 把列表1追加到l2中作为第二个元素，列表1的引用计数变为2
6

7
# 1. l1与l2之间有相互引用
8
# 2. l1 = ['xxx'的内存地址,列表2的内存地址]
9
# 3. l2 = ['yyy'的内存地址,列表1的内存地址]
10

11
print(l1)  # ['xxx', ['yyy', [...]]]
12

13
print(l2)  # ['yyy', ['xxx', [...]]]
14

15
del l1  # 列表1的引用计数减1，列表1的引用计数变为1
16
del l2  # 列表2的引用计数减1，列表2的引用计数变为1
17

18
print(l1)  # name 'l1' is not defined
19

20
print(l2)  # name 'l2' is not defined

• 此时，只剩下列表1与列表2之间的相互引用

• 但此时两个列表的引用计数均不为0，但两个列表不再被任何其他对象关联，没有任何人可以再引用到它们
  • 所以它俩占用内存空间应该被回收，但由于相互引用的存在，每一个对象的引用计数都不为0
  • 因此这些对象所占用的内存永远不会被释放，所以循环引用是致命的，这与手动进行内存管理所产生的内存泄露毫无区别。
• 所以Python引入了“标记-清除” 与“分代回收”来分别解决引用计数的循环引用与效率低的问题

（1）标记-清除算法#

• 在Python的内存管理中，标记-清除算法是一种常用的垃圾回收（Garbage Collection）方法之一。它的主要目标是解决循环引用导致的内存泄漏问题。
• 通俗理解为当内存空间即将沾满的时候，python会暂停程序的运行，从头到位扫描一遍，并且把扫描出来的垃圾数据做标记，然后，一次性做清除处理
• 容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。
  • 而“标记-清除”计数就是为了解决循环引用的问题。
• 标记/清除算法的做法是当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作

（2）标记阶段#

• 通俗地讲就是：栈区相当于“根”，凡是从根出发可以访达（直接或间接引用）的，都称之为“有根之人”，有根之人当活，无根之人当死。
• 标记GC Roots： 栈区中的所有内容或者线程都可以作为GC Roots对象。这些对象被认为是根源，是可达的。在标记阶段，遍历GC Roots对象，将可以直接或间接访问到的对象标记为存活对象。
• 标记存活对象： 遍历所有GC Roots的对象引用链，将可达的对象进行标记。这些对象将被保留，认为是存活的。

（3）清除阶段#

• 清除的过程将遍历堆中所有的对象，将没有标记的对象全部清除掉。
• 清除非存活对象： 遍历整个堆内存，将没有被标记的对象认定为非存活对象，进行清除操作。这些对象所占用的内存空间将被释放。

（4）循环引用的处理#

• 标记-清除算法解决了循环引用的问题。当两个对象互相引用，但与GC Roots没有直接引用关系时，它们在标记阶段将被标记为非存活对象，然后在清除阶段被释放。
• 基于上例的循环引用，当我们同时删除l1与l2时，会清理到栈区中l1与l2的内容以及直接引用关系

• 这样在启用标记清除算法时，从栈区出发，没有任何一条直接或间接引用可以访达l1与l2，即l1与l2成了“无根之人”，于是l1与l2都没有被标记为存活，二者会被清理掉，这样就解决了循环引用带来的内存泄漏问题。

（5）标记-清除的问题#

• 效率： 标记-清除算法可能导致程序在执行过程中停顿，因为在标记和清除阶段，程序的执行会被暂停一段时间。这可能会影响对实时性要求较高的应用程序。
• 空间碎片： 清除阶段释放的内存可能导致堆内存出现空间碎片。在长时间运行的程序中，这可能会导致内存的浪费。

（1）分代回收的核心思想#

• 分代回收是一种垃圾回收的策略，其核心思想是根据对象的存活时间将其划分为不同的代（generation）。
• 在Python中，通常将内存分为三代：
  • 新生代（young generation）： 包含了大部分新创建的对象，其存活时间较短。
  • 青春代（youth generation）： 包含了已经经历过垃圾回收一次的新生代对象，存活时间较长。
  • 老年代（old generation）： 包含了已经经历过多次垃圾回收的对象，存活时间较长。

（2）具体实现原理#

• 大部分对象在其刚被创建的时候往往很快变得不可达，即它们的生命周期较短。
• 部分对象在经历了一次垃圾回收后，仍然存活的概率较高，即它们的生命周期较长。
• 因此，分代回收将内存划分为不同的代，并根据代的特点采用不同的垃圾回收策略。
  • 新生代中的对象：采用较为频繁的垃圾回收，通常使用标记-复制算法，即标记存活对象，然后将存活对象复制到另一块内存中，最后清理掉原有的内存。这能有效处理新生代中大部分对象的垃圾回收。
  • 青春代中的对象：采用标记-清除算法，其目标是处理在新生代中经历了一次回收的对象。由于这些对象的生命周期较长，不需要频繁地进行回收。
  • 老年代中的对象：采用标记-清除算法或标记-整理算法。老年代的对象生命周期更长，采用相对稳定的垃圾回收策略。

1
分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）
2

3
新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，
4

5
青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，
6

7
接下来，青春代中的对象，也会以同样的方式被移动到老年代中。
8

9
也就是等级（代）越高，被垃圾回收机制扫描的频率越低

（3）回收#

• 分代回收机制对不同代的垃圾回收频率进行了调整：
  • 新生代的垃圾回收比较频繁，因为大部分对象在新生代中被创建后很快就变得不可达。
  • 青春代的垃圾回收频率较低，因为这些对象已经经历了一次回收，存活概率相对较高。
  • 老年代的垃圾回收频率较低，因为老年代的对象生命周期较长。

（4）分代回收的问题#

• 新生代到青春代的延迟问题： 当一个变量从新生代移入青春代时，其绑定关系解除，应该被回收。然而，由于青春代的扫描频率低于新生代，可能导致这些变量的垃圾没有得到及时的清理。
• 权重提升的不精确性： 分代回收中通过给对象的权重进行提升来判断其生命周期。然而，这种机制并不完美，可能存在一些不够准确的情况，导致有些垃圾对象没有被及时清理。
• 无法解决循环引用的所有问题： 尽管分代回收可以处理一些循环引用的情况，但并不能解决所有可能的循环引用问题。在某些情况下，仍然需要手动处理循环引用，例如通过显式地断开引用或使用弱引用。
• 全局解释器锁（GIL）： 在多线程的情况下，全局解释器锁可能会影响垃圾回收的效率，尤其是对于CPU密集型的任务。在处理大规模数据或高并发情况下，需要考虑GIL的影响。
• 没有十全十美的方案：
  • 毫无疑问，如果没有分代回收，即引用计数机制一直不停地对所有变量进行全体扫描，可以更及时地清理掉垃圾占用的内存，但这种一直不停地对所有变量进行全体扫描的方式效率极低，所以我们只能将二者中和。