Spring boot 随笔 1 DatasourceInitializer

简介

在 C 语言中,程序的内存分配主要包括以下几个部分:

代码段(Code Segment)

存储程序的可执行指令。
在程序执行期间是只读的,不可修改。
代码段的大小由编译器决定,取决于程序的复杂度。

数据段(Data Segment)

存储程序中定义的全局变量和静态变量。
数据段又可以分为:

初始化的数据段

存储被初始化的全局和静态变量。

未初始化的数据段(BSS 段)

存储未初始化的全局和静态变量。

数据段的大小由编译器根据程序中的全局变量和静态变量来决定。

堆(Heap)

用于动态内存分配,由程序员通过 malloc()、calloc()、realloc() 等函数来分配和管理。
堆内存的大小可以在运行时动态增加或减少。
堆内存由操作系统管理,程序员需要手动申请和释放内存。

栈(Stack)

用于存储函数的局部变量和函数调用信息。
在函数调用时,函数的参数、返回地址和局部变量会被压入栈中。函数返回时,这些信息会被弹出。
栈内存的大小由操作系统决定,通常较小。
栈内存由编译器自动管理,程序员不需要手动申请和释放。

内存管理的各种方式

静态内存分配

对于全局变量和静态变量,编译器会在编译时确定其大小并分配在数据段中。
这些变量的内存在程序运行期间保持不变。

// 定义全局变量和静态变量
int global_var = 10;
static int static_var = 20;

void func1() {
    // 访问全局变量和静态变量
    printf("global_var: %d, static_var: %d\n", global_var, static_var);
}

int main() {
    func1();
    return 0;
}

自动内存分配

对于函数内的局部变量,编译器会在函数调用时在栈上分配内存。
函数返回时,这些局部变量的内存会被自动释放。

void func2(int param) {
    // 定义局部变量
    int local_var = 30;
    static int static_local_var = 40;

    printf("param: %d, local_var: %d, static_local_var: %d\n", param, local_var, static_local_var);
    static_local_var++;
}

int main() {
    // 多次调用 func2
    func2(50);
    func2(60);
    func2(70);
    return 0;
}

动态内存分配

通过调用 malloc()、calloc()、realloc() 等函数在堆上动态分配内存。
程序员需要手动申请和释放内存,否则可能导致内存泄漏。

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 动态分配内存
    int* ptr = (int*)malloc(sizeof(int) * 5);
    if (ptr == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    // 初始化动态分配的内存
    for (int i = 0; i < 5; i++) {
        ptr[i] = i * 10;
    }

    // 使用动态分配的内存
    for (int i = 0; i < 5; i++) {
        printf("ptr[%d]: %d\n", i, ptr[i]);
    }

    // 释放动态分配的内存
    free(ptr);
    return 0;
}

指针操作

指针可以用来访问和操作内存中的数据。
通过指针运算,可以实现对内存的灵活访问和管理。

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int* ptr = arr;  // 让指针指向数组的首地址

    // 通过指针遍历数组
    for (int i = 0; i < 5; i++) {
        printf("arr[%d]: %d, *(ptr + %d): %d\n", i, arr[i], i, *(ptr + i));
    }

    // 通过指针修改数组元素
    *(ptr + 2) = 300;
    printf("arr[2]: %d\n", arr[2]);

    return 0;
}

内存管理函数

C 标准库提供了一系列内存管理函数,如 memcpy()、memmove()、memset() 等。
这些函数可以帮助程序员更方便地操作内存。

#include <stdio.h>
#include <string.h>

int main() {
    char src[] = "Hello, world!";
    char dst[20];

    // 使用 memcpy() 复制内存
    memcpy(dst, src, strlen(src) + 1);
    printf("dst: %s\n", dst);

    // 使用 memmove() 移动内存
    memmove(dst, src + 6, 5);
    printf("dst: %s\n", dst);

    // 使用 memset() 设置内存
    memset(dst, 'x', 10);
    printf("dst: %s\n", dst);

    return 0;
}

内存对齐

编译器会根据硬件特性对变量进行内存对齐,以提高访问效率。
程序员需要了解内存对齐规则,以避免出现内存对齐问题。内存对齐的规则一般有以下几种：

基本数据类型对齐

每种基本数据类型都有一个自身的对齐要求,通常为 1、2、4 或 8 字节。
编译器会自动将变量分配到满足其对齐要求的内存地址上。

结构体对齐

结构体中的成员变量会根据其自身的对齐要求进行对齐。
结构体整体的对齐要求是其所有成员中最大对齐要求的整数倍。
编译器会在结构体成员之间添加填充字节,以满足整体对齐要求。

数组对齐

数组中的元素会根据元素类型的对齐要求进行对齐。
数组整体的对齐要求是数组元素类型的对齐要求。

联合体对齐

联合体中的成员变量会根据最大成员的对齐要求进行对齐。
联合体整体的对齐要求是最大成员对齐要求的整数倍。

指针对齐

指针变量的对齐要求通常与其指向的数据类型的对齐要求相同。
指针运算时需要考虑对齐要求,以确保访问的是合法的内存地址。

跨平台对齐

不同的 CPU 架构和编译器可能会有不同的内存对齐规则。
程序员需要了解目标平台的对齐要求,以确保程序的正确性和可移植性。

内存泄漏检测

一些内存泄漏检测工具,如 valgrind、Address Sanitizer 等,可以帮助检测和定位内存泄漏问题。

如何避免内存的碎片化

C 语言虽然没有像 大多数语言那样内置的内存池机制,但开发者可以自行实现类似的内存池机制来避免内存碎片问题。

在 C 语言中,一些常见的内存池实现方式包括:

自定义内存池

程序员可以自行实现一个内存池,使用 malloc() 在堆上分配一大块内存作为内存池。
在需要内存时,从内存池中分配,避免了频繁的 malloc() 和 free() 调用。
释放内存时,将内存块返回到内存池,而不是直接调用 free()。
这种方式可以有效地减少内存碎片,提高内存利用率。

内存块管理

程序员可以自行实现一个内存块管理器,维护一个空闲内存块链表。
在需要内存时,从空闲链表中分配,如果链表为空则再调用 malloc() 分配新的内存块。
释放内存时,将内存块加入到空闲链表中,以便后续重复利用。
这种方式可以有效地减少内存碎片,提高内存利用率。

内存池库:

一些第三方库提供了内存池的实现,如 Doug Lea 的 dlmalloc 和 Emery Berger 的 jemalloc。
这些库可以替换系统提供的 malloc() 和 free() 实现,提供更好的内存管理能力。
它们通常采用复杂的内存管理算法,可以有效地减少内存碎片,提高内存利用率。

需要注意的是,C 语言的内存池实现需要程序员自行设计和实现,相对来说比较复杂。但如果程序中涉及大量的内存分配和释放,采用自定义的内存池机制可以明显提高程序的性能和稳定性。

简单示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 静态内存分配
int global_var = 10;
static int static_var = 20;

// 内存池实现
#define POOL_SIZE 1024 * 1024 // 1MB 内存池
typedef struct MemoryBlock {
    struct MemoryBlock* next;
    size_t size;
    int in_use;
} MemoryBlock;

MemoryBlock* memory_pool = NULL;

void* pool_malloc(size_t size) {
    MemoryBlock* block = memory_pool;
    while (block != NULL) {
        if (!block->in_use && block->size >= size) {
            block->in_use = 1;
            return block + 1;
        }
        block = block->next;
    }

    block = malloc(sizeof(MemoryBlock) + size);
    block->next = memory_pool;
    block->size = size;
    block->in_use = 1;
    memory_pool = block;
    return block + 1;
}

void pool_free(void* ptr) {
    MemoryBlock* block = (MemoryBlock*)ptr - 1;
    block->in_use = 0;
}

int main() {
    // 静态内存分配
    printf("Global variable: %d\n", global_var);
    printf("Static variable: %d\n", static_var);

    // 栈式内存分配
    int stack_var = 30;
    printf("Stack variable: %d\n", stack_var);

    // 堆式内存分配
    int* heap_var = (int*)malloc(sizeof(int));
    *heap_var = 40;
    printf("Heap variable: %d\n", *heap_var);
    free(heap_var);

    // 内存池
    memory_pool = malloc(POOL_SIZE);
    memory_pool->next = NULL;
    memory_pool->size = POOL_SIZE - sizeof(MemoryBlock);
    memory_pool->in_use = 0;

    void* pool_ptr = pool_malloc(sizeof(int));
    *(int*)pool_ptr = 50;
    printf("Memory pool variable: %d\n", *(int*)pool_ptr);
    pool_free(pool_ptr);

    return 0;
}

在这个示例中,我们展示了以下几种内存分配方式:

静态内存分配:通过全局变量和静态变量实现。
栈式内存分配:通过局部变量实现。
堆式内存分配:使用 malloc() 函数在堆上分配内存。
自定义内存池:实现了一个简单的内存池,包括 pool_malloc() 和 pool_free() 函数。