MiNiKou的博客

1
void example() {
2
    int a = 10;           // 栈区：函数返回时自动销毁
3
    int* p = new int(20); // 堆区：程序员负责释放
4

5
    delete p;             // ✅ 手动释放
6
    p = nullptr;          // ✅ 防止野指针
7
}
8
// 函数返回，a 自动销毁；若忘记 delete p，内存泄漏！

1
#include <fstream>
2

3
class FileGuard {
4
    std::fstream file;
5
public:
6
    FileGuard(const std::string& path) {
7
        file.open(path);    // 构造时获取资源
8
    }
9
    ~FileGuard() {
10
        if (file.is_open()) file.close();  // 析构时自动释放
11
    }
12
};
13

14
void process() {
15
    FileGuard f("data.txt");   // 构造时打开文件
16
    // ... 使用文件 ...
17
    // 函数返回（或抛出异常），f 析构，文件自动关闭
18
}   // ✅ 无论正常返回还是异常，资源都被释放

1
#include <memory>
2

3
// unique_ptr：独占所有权，不可复制，只可移动
4
std::unique_ptr<int> up = std::make_unique<int>(42);
5
// auto up2 = up;    // ❌ 编译错误，不可复制
6
auto up2 = std::move(up);  // ✅ 转移所有权，up 变为空
7

8
// shared_ptr：共享所有权，内部维护引用计数
9
std::shared_ptr<int> sp1 = std::make_shared<int>(100);
10
std::shared_ptr<int> sp2 = sp1;   // 引用计数 = 2
11
// sp1、sp2 都析构后，引用计数归零，内存释放
12

13
// weak_ptr：弱引用，不增加引用计数，用于打破循环引用
14
std::weak_ptr<int> wp = sp1;
15
// 使用前需检查是否有效
16
if (auto sp3 = wp.lock()) {
17
    std::cout << *sp3;   // 安全访问
18
}

1
// ❌ 问题 1：内存泄漏（忘记 delete）
2
int* p = new int(10);
3
// 忘记 delete p; → 泄漏
4

5
// ❌ 问题 2：野指针（使用已释放的内存）
6
int* p2 = new int(20);
7
delete p2;
8
*p2 = 30;   // 未定义行为！
9

10
// ❌ 问题 3：double-free（重复释放）
11
int* p3 = new int(30);
12
delete p3;
13
delete p3;  // 崩溃！
14

15
// ❌ 问题 4：数组越界（最常见的安全漏洞）
16
int arr[5];
17
arr[10] = 0;  // 越界写入，可能覆盖栈上其他数据
18

19
// ✅ 现代 C++ 解决方案：用 RAII + 智能指针 + 标准库容器
20
auto p4 = std::make_unique<int>(40);   // 自动释放
21
std::vector<int> v(5);                 // 自动管理大小

1
JVM 堆内存结构（基于分代模型）：
2
┌─────────────────────────────────────────────────────┐
3
│                       堆 (Heap)                      │
4
│  ┌──────────────────────┐  ┌───────────────────────┐ │
5
│  │     新生代 (Young)    │  │    老年代 (Old/Tenured)│ │
6
│  │  ┌──────┬─────┬─────┐│  │                       │ │
7
│  │  │ Eden │ S0  │ S1  ││  │  长期存活的对象        │ │
8
│  │  │（新对象）│(幸存区)││  │                       │ │
9
│  │  └──────┴─────┴─────┘│  └───────────────────────┘ │
10
│  └──────────────────────┘                             │
11
└─────────────────────────────────────────────────────┘

1
新对象创建
2
     ↓
3
  Eden 区  ←───── Minor GC（频繁触发）
4
     ↓ 存活
5
  Survivor 区（S0 ↔ S1 来回复制）
6
     ↓ 年龄达到阈值（默认 15 次）
7
  老年代（Old Gen）
8
     ↓ 空间不足
9
  Full GC（Stop-The-World，代价最高）

1
// 理解对象晋升：年龄计数器
2
// 每次 Minor GC 存活，年龄 +1
3
// 超过 MaxTenuringThreshold（默认 15）→ 晋升老年代
4

5
// JVM 参数调优示例
6
// -Xms512m -Xmx2g          设置堆初始/最大大小
7
// -XX:NewRatio=2            老年代:新生代 = 2:1
8
// -XX:+UseG1GC              使用 G1 收集器
9
// -XX:MaxGCPauseMillis=200  G1 目标最大停顿时间

1
// ❌ 场景 1：静态集合无限增长
2
public class LeakExample {
3
    private static List<Object> cache = new ArrayList<>();
4

5
    public void addToCache(Object obj) {
6
        cache.add(obj);   // 静态集合持有引用，GC 无法回收
7
    }
8
}
9

10
// ❌ 场景 2：未关闭的资源
11
Connection conn = dataSource.getConnection();
12
// 忘记 conn.close() → 连接泄漏
13

14
// ✅ 使用 try-with-resources
15
try (Connection conn = dataSource.getConnection()) {
16
    // 自动关闭
17
}
18

19
// ❌ 场景 3：内部类持有外部类引用
20
public class Outer {
21
    private int[] data = new int[1000000];
22

23
    class Inner {   // 非静态内部类隐式持有 Outer 引用
24
        void doSomething() {}
25
    }
26
}
27
// 即使 Outer 不再使用，只要 Inner 存在，Outer（及 data 数组）就无法被回收
28

29
// ✅ 改为静态内部类
30
static class Inner { ... }

1
a = 10      # 变量 a 指向堆上的整数对象 10
2
b = a       # 变量 b 指向同一个对象，并非复制
3
a = 20      # a 重新指向新对象 20，b 仍指向 10
4

5
print(b)               # 输出 10，b 未受影响
6
print(id(a) == id(b))  # False，两者指向不同对象

1
import sys
2

3
a = [1, 2, 3]
4
print(sys.getrefcount(a))  # 输出 2（a 本身 + getrefcount 参数各占一次）
5

6
b = a
7
print(sys.getrefcount(a))  # 输出 3
8

9
del b
10
print(sys.getrefcount(a))  # 回到 2

1
# 循环引用：引用计数的致命弱点
2
a = []
3
b = []
4
a.append(b)   # b 的引用计数 = 1
5
b.append(a)   # a 的引用计数 = 1
6

7
del a          # a 的引用计数变为 1（b 还引用着它）
8
del b          # b 的引用计数变为 1（a 还引用着它）
9
# 两者引用计数都是 1，但没有任何外部变量能访问它们
10
# 引用计数机制无法回收 ——「内存泄漏」就这样发生了

1
import gc
2

3
print(gc.get_threshold())   # (700, 10, 10)
4
print(gc.get_count())       # 各代当前对象数量
5

6
gc.collect()                # 手动触发，回收所有代

1
a = 256
2
b = 256
3
print(a is b)   # True ✅
4

5
a = 257
6
b = 257
7
print(a is b)   # False ❌（标准 CPython 中）
8
# 注意：不要在生产代码中依赖这个行为

1
a = "hello"
2
b = "hello"
3
print(a is b)       # True，自动驻留
4

5
a = "hello world"   # 含空格，不自动驻留
6
b = "hello world"
7
print(a is b)       # False
8

9
import sys
10
a = sys.intern("hello world")
11
b = sys.intern("hello world")
12
print(a is b)       # True，手动驻留

1
Arena（竞技场）：约 256KB，直接向 OS 申请
2
  └── Pool（内存池）：4KB，管理同一尺寸类别的对象
3
        └── Block（内存块）：实际存储对象的最小单元

1
# ❌ 场景 1：循环引用（不使用 weakref）
2
import weakref
3

4
class Node:
5
    def __init__(self, value):
6
        self.value = value
7
        self.parent = None
8

9
node = Node(1)
10
tree_obj = object()
11
node.parent = tree_obj   # ❌ 强引用可能形成循环
12

13
node.parent = weakref.ref(tree_obj)  # ✅ 弱引用不增加引用计数
14

15
# ❌ 场景 2：全局缓存无限增长
16
_cache = []
17
def process(data):
18
    result = compute(data)
19
    _cache.append(result)   # 永远不清理 = 泄漏
20

21
# ❌ 场景 3：未关闭的资源
22
# with 语句是 Python 的 RAII 等价物
23
with open("data.txt") as f:   # ✅ 自动关闭
24
    data = f.read()
25

26
# ❌ 场景 4：__del__ 中的副作用（Python 3.4+ 已修复循环引用问题）
27
class BadClass:
28
    def __del__(self):
29
        print("被销毁了")   # 有 __del__ 的对象慎用循环引用

1
# 工具 1：tracemalloc（内置）
2
import tracemalloc
3
tracemalloc.start()
4
# ... 你的代码 ...
5
snapshot = tracemalloc.take_snapshot()
6
for stat in snapshot.statistics("lineno")[:5]:
7
    print(stat)
8

9
# 工具 2：objgraph（pip install objgraph）
10
import objgraph
11
objgraph.show_growth()          # 显示增长最快的对象类型
12
objgraph.show_backrefs(obj)     # 显示谁在引用这个对象
13

14
# 工具 3：memory_profiler（pip install memory-profiler）
15
# 在函数上加 @profile，然后 python -m memory_profiler script.py

1
# 默认实例用 __dict__ 存储属性，灵活但费内存
2
class Normal:
3
    def __init__(self, x, y):
4
        self.x = x
5
        self.y = y
6

7
class WithSlots:
8
    __slots__ = ["x", "y"]   # 去掉 __dict__，大量实例时节省 40-50% 内存
9
    def __init__(self, x, y):
10
        self.x = x
11
        self.y = y

1
squares = [x**2 for x in range(10_000_000)]   # ❌ 约 80MB
2
squares = (x**2 for x in range(10_000_000))   # ✅ 约 112 字节

1
import gc
2
def process_large_data():
3
    data = load_huge_dataset()
4
    result = analyze(data)
5
    del data       # 引用计数归零，立即释放
6
    gc.collect()   # 清理潜在的循环引用
7
    return result

1
import weakref
2

3
class Cache:
4
    def __init__(self):
5
        self._cache = weakref.WeakValueDictionary()  # value 被回收后 key 自动移除

1
import array, numpy as np
2

3
lst = list(range(1_000_000))                        # 约 8MB
4
arr = array.array("i", range(1_000_000))            # 约 4MB
5
np_arr = np.arange(1_000_000, dtype=np.int32)       # 约 4MB，运算更快