C语言中用匿名结构体实现Singleton的问题（含多线程）及解决办法

问题描述 #

我想在C语言中用匿名结构体定义全局变量实现单例：利用匿名结构体无法创建其他实例的特性，代码如下：

#ifndef __for_including_this_file_once__
#define __for_including_this_file_once__

struct { 
    // 结构体成员变量
} singleton_struct;

#endif // __for_including_this_file_once__

只要包含该头文件，就能在任意位置访问这个实例。想知道这种实现方式存在哪些问题（尤其是多线程场景下），以及可行的解决办法？

存在的问题 #

1. 链接阶段重复定义错误 #

虽然加了头文件保护，但每个包含该头文件的源文件都会生成一个singleton_struct的全局定义。链接器会检测到重复的全局符号，直接抛出多重定义错误，导致程序无法编译通过。

2. 静态初始化顺序依赖问题 #

全局变量的初始化在main函数之前完成，属于静态初始化。如果这个单例依赖其他全局变量的初始化结果，可能出现依赖变量未完成初始化、单例就已经初始化的情况，触发未定义行为。

3. 多线程场景的线程安全问题 #

• 初始化阶段：如果后续为单例增加了动态初始化逻辑（比如运行时加载资源），多个线程同时触发初始化会导致重复创建实例，或者出现数据竞争；
• 读写阶段：即使单例静态初始化完成，多个线程同时读写其成员变量时，无同步机制会引发数据竞争，导致程序行为不可控。

4. 可维护性与扩展性缺失 #

匿名结构体无法被复用，也无法通过指针类型做抽象扩展。后续如果需要修改单例结构、或者实现同类型的其他单例，只能完全重写代码，维护成本极高。

可行的解决办法 #

1. 分离声明与定义，避免重复定义 #

将结构体定义和全局变量声明放在头文件，变量定义仅在单个源文件中实现：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

typedef struct {
    // 成员变量
} Singleton;

// 仅声明变量，不定义
extern Singleton singleton_instance;

#endif // SINGLETON_H

// singleton.c
#include "singleton.h"

// 仅在一个源文件中定义全局变量
Singleton singleton_instance = {
    // 初始化成员
};

2. 懒加载+互斥锁实现线程安全初始化 #

适合需要延迟初始化的场景（比如依赖运行时资源），用互斥锁保证初始化的原子性：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

typedef struct {
    // 成员变量
} Singleton;

Singleton* get_singleton(void);
void destroy_singleton(void);

#endif // SINGLETON_H

// singleton.c
#include "singleton.h"
#include <stdlib.h>
#include <pthread.h>

static Singleton* instance = NULL;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

Singleton* get_singleton(void) {
    // 双重检查锁定，减少锁竞争
    if (instance == NULL) {
        pthread_mutex_lock(&mutex);
        if (instance == NULL) {
            instance = malloc(sizeof(Singleton));
            // 初始化成员变量
            instance->xxx = 0;
        }
        pthread_mutex_unlock(&mutex);
    }
    return instance;
}

// 程序退出时释放资源
void destroy_singleton(void) {
    pthread_mutex_lock(&mutex);
    if (instance != NULL) {
        free(instance);
        instance = NULL;
    }
    pthread_mutex_unlock(&mutex);
}

注意：C11及以上版本可以用_Atomic修饰instance，避免编译器优化导致的内存可见性问题。

3. 静态初始化+读写同步 #

如果单例是静态初始化完成的，针对多线程读写操作添加互斥锁：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <pthread.h>

typedef struct {
    int counter;
    // 其他成员
} Singleton;

extern Singleton singleton_instance;
extern pthread_mutex_t singleton_mutex;

#endif // SINGLETON_H

// singleton.c
#include "singleton.h"

Singleton singleton_instance = {0};
pthread_mutex_t singleton_mutex = PTHREAD_MUTEX_INITIALIZER;

访问单例成员时必须加锁：

// 线程中读写示例
pthread_mutex_lock(&singleton_mutex);
singleton_instance.counter++;
pthread_mutex_unlock(&singleton_mutex);

4. C11原子变量实现无锁初始化 #

利用C11的原子操作API，实现无锁的线程安全懒加载：

// singleton.c
#include "singleton.h"
#include <stdlib.h>
#include <stdatomic.h>

static _Atomic(Singleton*) instance = NULL;

Singleton* get_singleton(void) {
    Singleton* temp = atomic_load(&instance);
    if (temp == NULL) {
        temp = malloc(sizeof(Singleton));
        // 初始化成员
        temp->xxx = 0;
        // 原子比较交换：如果instance还是NULL，就把temp赋值给它
        if (!atomic_compare_exchange_strong(&instance, &temp, NULL)) {
            // 其他线程已完成初始化，释放当前分配的内存
            free(temp);
            temp = atomic_load(&instance);
        }
    }
    return temp;
}

内容的提问来源于stack exchange，提问作者Ak2399