redis太大了，请使用C语言给出一个性能好、稳定性高，稍微简单一点的缓存代码。需求是存储变长的数据，支持多线程，即需要支持多线程安全耽误进行读写操作，最好使用无锁化来实现-Go服务器开发

下面是一个简单的基于 C 语言的缓存实现，使用了无锁化（lock-free）的设计模式。为了实现这个需求，我们将使用原子操作来确保线程安全。同时，为了简化实现，我们将采用链表存储变长的数据。

注意：这个示例只是为了展示基本思路，并未经过完整测试。在实际生产环境中，需要进一步优化和完善错误处理、内存管理等细节。

无锁缓存代码示例

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

typedef struct Node {
    char *data;
    struct Node *next;
} Node;

typedef struct Cache {
    Node *head;
} Cache;

// 创建新的缓存
Cache* create_cache() {
    Cache *cache = (Cache *)malloc(sizeof(Cache));
    cache->head = NULL;
    return cache;
}

// 向缓存添加数据
void add_to_cache(Cache *cache, const char *data) {
    size_t len = strlen(data);
    char *copy_data = (char *)malloc(len + 1);
    strcpy(copy_data, data);

    Node *new_node = (Node *)malloc(sizeof(Node));
    new_node->data = copy_data;
    
    // 设置新节点的指向为当前头节点
    do {
        new_node->next = atomic_load(&cache->head);
    } while (!atomic_compare_exchange_weak(&cache->head, &new_node->next, new_node));
}

// 从缓存中读取数据
char* get_from_cache(Cache *cache) {
    Node *current_head = atomic_load(&cache->head);
    
    if (current_head == NULL) {
        return NULL; // 缓存为空
    }
    
    // 读取头节点的数据并更新头节点为下一个节点
    atomic_store(&cache->head, current_head->next);
    
    char *result = current_head->data; // 获取数据
    
    free(current_head); // 释放当前节点内存（不释放数据内存）
    
    return result; // 返回数据
}

// 清理缓存及其内容
void free_cache(Cache *cache) {
    Node *current = atomic_load(&cache->head);
    
    while (current != NULL) {
        Node *next = current->next;
        free(current->data); // 释放数据内存
        free(current);       // 释放节点内存
        current = next;
    }

    free(cache);
}

int main() {
   Cache* cache = create_cache();

   add_to_cache(cache, "Hello");
   add_to_cache(cache, "World");

   printf("%s\n", get_from_cache(cache)); // World
   printf("%s\n", get_from_cache(cache)); // Hello

   free_cache(cache);
   
   return 0;
}

简要说明：

Node结构体: 定义了一个链表节点，用于存储变长的数据。
Cache结构体: 包含一个指向链表头部的指针。
add_to_cache函数: 使用无锁算法添加新的数据到缓存。通过原子比较交换 (atomic_compare_exchange_weak) 确保多线程环境下安全地更新链表头部。
get_from_cache函数: 安全地获取并删除链表中的头部元素，同样使用原子操作来更新头指针。
free_cache函数: 清理所有动态分配的内存以防止泄漏。