Linux c实现一个线程安全的单链表

已于 2024-09-12 11:54:13 修改
阅读量1.2k 收藏 7
点赞数
文章标签： 链表 数据结构 单链表
于 2020-08-06 16:39:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42161913/article/details/107843447
版权

slist.h

#ifndef SLIST_H
#define SLIST_H

#include <pthread.h>
#include <stdbool.h>

// 单链表节点结构
typedef struct SListNode
{
    void *pdata;            // 存储数据的指针
    struct SListNode *next; // 指向下一个节点的指针
} SListNode;

// 单链表结构
typedef struct SList
{
    SListNode *head;      // 链表的头指针
    pthread_mutex_t lock; // 互斥锁
} SList;

// 比较函数指针类型，返回值为0表示相等
typedef int (*CompareCallback)(void *pdata1, void *pdata2);

// 释放函数指针类型
typedef void (*FreeCallback)(void *pdata);

// 遍历函数指针类型
typedef void (*TraverseCallback)(const void *pdata, void *arg);

/**
 * 初始化链表。
 *
 * @param list 需要初始化的链表指针。
 * @return 初始化是否成功（0 表示成功，-1 表示失败）。
 */
int slist_init(SList *list);

/**
 * 销毁链表，释放所有资源。
 *
 * @param list 需要销毁的链表指针。
 * @param free_cb 自定义的释放函数，如果为 NULL，使用 free。
 */
void slist_destroy(SList *list, FreeCallback free_cb);

/**
 * 添加数据
 *
 * @param list 链表指针。
 * @param pdata 要添加的数据指针。
 * @param size 数据的大小。
 * @return 操作是否成功（0 表示成功，-1 表示失败）。
 */
int slist_insert(SList *list, void *pdata, size_t size);

/**
 * 删除数据
 *
 * @param list 链表指针。
 * @param pdata 要删除的节点数据指针。
 * @param compare_cb 自定义的比较函数。
 * @param free_cb 自定义的释放函数，如果为 NULL，使用 free。
 * @return 操作是否成功（0 表示成功，-1 表示失败）。
 */
int slist_remove(SList *list, void *pdata, CompareCallback compare_cb, FreeCallback free_cb);

/**
 * 查找数据
 *
 * @param list 链表指针。
 * @param pdata 要查找的数据指针。
 * @param compare_cb 自定义的比较函数。
 * @return 如果找到，返回对应的节点数据；否则返回 NULL。
 */
const void *slist_find(SList *list, void *pdata, CompareCallback compare_cb);

/**
 * 修改数据
 *
 * @param list 链表指针。
 * @param old_data 需要修改的节点数据指针。
 * @param new_data 替换为的新数据指针。
 * @param size 数据的大小。
 * @param compare_cb 自定义的比较函数。
 * @return 操作是否成功（0 表示成功，-1 表示失败）。
 */
int slist_modify(SList *list, void *old_data, void *new_data, size_t size,
                 CompareCallback compare_cb);

/**
 * 遍历链表
 *
 * @param list 链表指针。
 * @param traverse_cb 自定义的遍历函数。
 * @param arg 回调携带的参数。
 * @return 操作是否成功（0 表示成功，-1 表示失败）。
 */
int slist_foreach(SList *list, TraverseCallback traverse_cb, void *arg);

/**
 * 遍历链表
 *
 * @param list 链表指针。
 * @param pdata 遍历到的节点数据指针，函数内部会分配内存，需要调用者释放。
 * @param count 遍历到的节点数量。
 * @return 操作是否成功（0 表示成功，-1 表示失败）。
 */
int slist_foreach2(SList *list, void ***pdata, size_t *count);

/**
 * 释放遍历链表时分配的内存。
 *
 * @param pdata 遍历到的节点数据指针。
 * @return 无。
 */
void slist_free_foreach2(void ***pdata);

/**
 * 获取链表中元素数量
 *
 * @param list 链表指针。
 * @return 链表中元素的数量。
 */
size_t slist_size(SList *list);

/**
 * 链表是否为空。
 *
 * @param list 链表指针。
 * @return 如果链表为空，返回 true；否则返回 false。
 */
bool slist_empty(SList *list);

/**
 * 清空链表，释放所有节点。
 *
 * @param list 链表指针。
 * @param free_cb 自定义的释放函数，如果为 NULL，使用 free。
 * @return 无。
 */
void slist_clear(SList *list, FreeCallback free_cb);

#endif // SLIST_H

slist.c

#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "slist.h"

int slist_init(SList *list)
{
    list->head = NULL;
    if (pthread_mutex_init(&list->lock, NULL) != 0)
    {
        return -1; // 初始化互斥锁失败
    }
    return 0;
}

void slist_destroy(SList *list, FreeCallback free_cb)
{
    pthread_mutex_lock(&list->lock);

    SListNode *current = list->head;
    while (current)
    {
        SListNode *next = current->next;
        // 释放节点数据，如果没提供自定义释放函数，使用free
        (free_cb) ? free_cb(current->pdata) : free(current->pdata);
        free(current);
        current = next;
    }
    list->head = NULL;

    pthread_mutex_unlock(&list->lock);
    pthread_mutex_destroy(&list->lock);
}

int slist_insert(SList *list, void *pdata, size_t size)
{
    SListNode *new_node = (SListNode *)malloc(sizeof(SListNode));
    uint8_t *data = (uint8_t *)malloc(size);
    if (!new_node || !data)
    {
        free(new_node);
        free(data);
        return -1; // 分配内存失败
    }
    memcpy(data, pdata, size);
    new_node->pdata = data;
    pthread_mutex_lock(&list->lock);

    // 头插法
    new_node->next = list->head;
    list->head = new_node;

    pthread_mutex_unlock(&list->lock);
    return 0;
}

int slist_remove(SList *list, void *pdata, CompareCallback compare_cb, FreeCallback free_cb)
{
    if (!compare_cb)
    {
        return -1;
    }
    pthread_mutex_lock(&list->lock);

    SListNode *current = list->head;
    SListNode *previous = NULL;

    while (current)
    {
        if (compare_cb(current->pdata, pdata) == 0)
        {
            if (previous)
            {
                previous->next = current->next;
            }
            else
            {
                list->head = current->next;
            }
            (free_cb) ? free_cb(current->pdata) : free(current->pdata);
            free(current);
            pthread_mutex_unlock(&list->lock);
            return 0;
        }
        previous = current;
        current = current->next;
    }

    pthread_mutex_unlock(&list->lock);
    return -1; // 未找到数据
}

const void *slist_find(SList *list, void *pdata, CompareCallback compare_cb)
{
    if (!compare_cb)
    {
        return NULL;
    }
    pthread_mutex_lock(&list->lock);

    SListNode *current = list->head;
    while (current)
    {
        if (compare_cb(current->pdata, pdata) == 0)
        {
            pthread_mutex_unlock(&list->lock);
            return current->pdata;
        }
        current = current->next;
    }

    pthread_mutex_unlock(&list->lock);
    return NULL; // 未找到数据
}

int slist_modify(SList *list, void *old_data, void *new_data, size_t size,
                 CompareCallback compare_cb)
{
    if (!compare_cb)
    {
        return -1;
    }
    pthread_mutex_lock(&list->lock);

    SListNode *current = list->head;
    while (current)
    {
        if (compare_cb(current->pdata, old_data) == 0)
        {
            memcpy(current->pdata, new_data, size);
            pthread_mutex_unlock(&list->lock);
            return 0;
        }
        current = current->next;
    }

    pthread_mutex_unlock(&list->lock);
    return -1; // 未找到数据
}

int slist_foreach(SList *list, TraverseCallback traverse_cb, void *arg)
{
    if (!traverse_cb)
    {
        return -1;
    }
    pthread_mutex_lock(&list->lock);

    SListNode *current = list->head;
    while (current)
    {
        traverse_cb(current->pdata, arg);
        current = current->next;
    }

    pthread_mutex_unlock(&list->lock);
    return 0;
}

int slist_foreach2(SList *list, void ***pdata, size_t *count)
{
    pthread_mutex_lock(&list->lock);

    size_t size = 0;
    SListNode *current = list->head;

    while (current)
    {
        size++;
        current = current->next;
    }
    *pdata = (void *)malloc(sizeof(void *) * size);
    if (!*pdata)
    {
        pthread_mutex_unlock(&list->lock);
        return -1; // 分配内存失败
    }

    current = list->head;
    for (size_t i = 0; i < size; i++)
    {
        (*pdata)[i] = current->pdata;
        current = current->next;
    }
    *count = size;

    pthread_mutex_unlock(&list->lock);
    return 0;
}

void slist_free_foreach2(void ***pdata)
{
    free(*pdata);
    *pdata = NULL;
}

size_t slist_size(SList *list)
{
    size_t size = 0;
    pthread_mutex_lock(&list->lock);

    SListNode *current = list->head;
    while (current)
    {
        size++;
        current = current->next;
    }

    pthread_mutex_unlock(&list->lock);
    return size;
}

bool slist_empty(SList *list)
{
    pthread_mutex_lock(&list->lock);

    bool is_empty = (list->head == NULL);

    pthread_mutex_unlock(&list->lock);
    return is_empty;
}

void slist_clear(SList *list, FreeCallback free_cb)
{
    pthread_mutex_lock(&list->lock);

    SListNode *next = NULL;
    SListNode *current = list->head;
    while (current)
    {
        next = current->next;
        (free_cb) ? free_cb(current->pdata) : free(current->pdata);
        free(current);
        current = next;
    }
    list->head = NULL;

    pthread_mutex_unlock(&list->lock);
}

测试：

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

int CompareFun(void *pdata1, void *pdata2)
{
    return *(int *)pdata1 - *(int *)pdata2;
}

void TraverseFun(const void *pdata, void *)
{
    printf("%d\n", *(int *)pdata);
}

int main(void)
{
    SList list;
    int buf[10] = {0};

    for (int i = 0; i < 10; i++)
    {
        buf[i] = i;
    }

    slist_init(&list);
    for (int i = 0; i < 10; i++)
        slist_insert(&list, &buf[i], sizeof(int));

    printf("size = %zu\n", slist_size(&list));
    if (slist_empty(&list))
        printf("empty\n");
    else
        printf("not empty\n");

    // 遍历
    printf("--------\n");
    slist_foreach(&list, TraverseFun, NULL);
    printf("--------\n");

    size_t count = 0;
    void **pdata2 = NULL;
    slist_foreach2(&list, &pdata2, &count);
    printf("\ncount = %zu\n", count);
    printf("--------\n");
    for (size_t i = 0; i < count; i++)
    {
        printf("%d\n", *((int *)pdata2[i]));
    }
    printf("--------\n");
    slist_free_foreach2(&pdata2);

    const int *p = slist_find(&list, &buf[3], CompareFun);
    if (p)
        printf("found: %d\n", *p);
    else
        printf("Not found\n");

    printf("remove\n");
    slist_remove(&list, &buf[3], CompareFun, NULL);
    p = slist_find(&list, &buf[3], CompareFun);
    if (p)
        printf("found: %d\n", *p);
    else
        printf("Not found\n");

    int *pValue = (int *)malloc(sizeof(int));
    *pValue = 666;
    slist_modify(&list, &buf[0], pValue, sizeof(int), CompareFun);
    p = slist_find(&list, pValue, CompareFun);
    if (p)
        printf("found: %d\n", *p);
    else
        printf("Not found\n");

    printf("clear\n");
    slist_clear(&list, NULL);
    printf("size = %zu\n", slist_size(&list));
    if (slist_empty(&list))
        printf("empty\n");
    else
        printf("not empty\n");

    slist_destroy(&list, NULL);

    return 0;
}

测试输出：

size = 10
not empty
--------
9
8
7
6
5
4
3
2
1
0
--------

count = 10
--------
9
8
7
6
5
4
3
2
1
0
--------
found: 3
remove
Not found
found: 666
clear
size = 0
empty

静止了 所有的花开
关注
C++多线程--线程安全的队列实现(基于锁)
qls315的博客
04-11 1107
本文参考C++ Concurrency in Action (豆瓣)讲解并给出了完整的基于锁的线程安全的队列。下一篇讲解基于锁的哈希表。
Linux下的多线程编程二（线程的同步与互斥）
snow_5288的博客
06-14 4558
一、什么叫做线程的同步与互斥？为什么需要同步与互斥？ 二、互斥量 三、条件变量 四、信号量 五、读写锁
c语言单链表实现通讯录，支持保存数据到文件加载数据到文件
04-05
c语言单链表实现通讯录，支持添加数据、删除数据、查找数据、修改数据、排序、清空、支持保存数据到文件加载文件内数据。
单链表--c语言实现的带头结点的单链表
最新发布
weixin_51434601的博客
10-28 238
链表就是用一组任意的存储单元存储线性表中的元素，这组存储单元可以连续也可以不连续；为了表示每个元素与其后继元素之间的关系，链表上的每个结点node都至少有两个域，“数据域”和“指针域”；链表本身也是一种递归的数据结构； 链表的第一个结点叫“首元结点”，一般为了处理方便，通常会在首元结点前附设一个“头节点”，其指针域指向首元结点，而表指针通常固定指向头节点，头节点通常不存储数据或存表长；
【数据结构】C语言实现单链表（带头结点）
SHLYYY
05-04 2154
SLLWNode;// 在pos之前插入 void SLLWInsert(SLLWNode * phead , SLLWNode * pos , SLLWDataType x);// 在pos之后插入 void SLLWInsertAfter(SLLWNode * pos , SLLWDataType x);// 删除pos位置的值 void SLLWErase(SLLWNode * phead , SLLWNode * pos);
单链表（带头结点）的存储结构与基本操作（c语言）------亲测可用
热门推荐
大学僧成长纪的博客
12-18 1万+
实现功能：单链表（带头结点）结点结构体的定义，单链表（带头结点）初始化、求元素个数、插入元素、删除元素、取元素、打印所有元素、就地逆置、撤销的操作。
c语言实现单链表（带头结点）-可针对任意数据类型
hou19975418的博客
01-14 551
带头结点单链表的c语言实现，这里给出的接口比较少，功能比较简单，主要的知识点是typedef定义结构体类型后的指针定义（刚开始没想明白）、void*类型可以存储任意数据类型的指针、设置统一的接口（参数包含函数指针）并且给不同数据类型编写各自的打印函数来打印数据。我对于查找元素返回位置的逻辑进行了一点补充。所以这一点局限性比较大。
基于Linux c 用socket和线程 实现的简易聊天室之服务器
qq790456812的博客
02-26 1143
#include #include #include #include #include #include #include #include #define PORTNUMBER 9994 #define MAXNUM 10 #define OK 1 #define ERROR 0 typedef  int Elementtype;
c语言多线程性能调优,C++性能优化（八）——内存分配机制
weixin_29854481的博客
05-24 1410
C++性能优化(八)——内存分配机制一、操作系统内存布局1、32位系统经典内存布局Linux Kernel 2.6.7前版本采用的默认内存布局形式如下：(1)32操作系统中，loader将可执行文件的各个段次依次载入到从0x80048000(128M)位置开始的空间中。应用程序能够访问的最后地址是0xbfffffff(3G)的位置，3G以上的位置是给内核使用的，应用程序不能直接访问。(2)内存布局...
《C语言深度解析》第9、10章——位操作 /c标准IO、网络编程/线程/链表
06-12
本课程主要讲解以下内容：1. 位操作（位运算）2. c语言的标准IO函数3.标准IO与文件IO、常见标准IO函数有哪些、fopen/...多线程、网络编程、数据库、数据结构、顺序表、链表、单链表、双链表、队列/栈、Linux内核链表
C语言实现带头结点的单向链表的基本操作
04-04
使用C语言实现了单向链表的创建，输出，插入元素和删除元素以及单向链表的逆序连接和两个有序线性表的归并
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
c语言共用体实现任意数据类型的单链表
qq_38830492的博客
04-10 1417
我的单链表可支持任意数据类型，完成这个需求的方法很奇怪，用的是共用体。。
【数据结构】带头结点的单链表
VVVv_0427的博客
10-16 736
【数据结构】带头结点的单链表 链表：逻辑连续，物理上不一定连续 带头结点的单链表： 结构体： //定义结构体 typedef int ELEM_TYPE; typedef struct Node { ELEM_TYPE mdata; struct Node* pnext; }Node,*Link; 尾插： //给尾部插入 bool InsertTail(Link ph...
C语言通用数据类型链表的实现
学海无涯，回头是岸........
09-24 2508
可接受任意类型的数据的C语言链表的实现（说白了其实就是链表结构体中有一个void * 类型指针即可）      今天在宣讲会上讲了一下我所写的那个可以接收任意类型的参数类型的链表，感觉还是没有讲清楚，再次整理一下 ，同样的道理我们可以构造出其它的可以接受任意数据类型的结构，如：可接收任意数据类型的栈，可接收任意数据类型的队列，可接收任意数据类型的树················
C语言实现 单链表 处理任意类型数据
jakercl的博客
01-19 1393
企业开发中，C语言链表不仅仅存储基本数据类型，应对任意的void data均可实现增删改查。在前面的一篇文章中，已经分享了单向链表、双向链表、有头节点和无头节点等链表对基本数据的处理。以下主要分析对复杂类型数据的处理，是以无有效头节点的单向链表为例。 1 结构体构建Node节点 typedef struct Node //链表节点定义 { void *data; //节点的数据域，存址 struct Node *next; //指针域，保存下一个节点的地址，指向下一个节点
(数据结构)带头结点的单链表操作——C实现（新增一些面试经典题目）
qq_44824574的博客
07-21 1324
带头结点的单链表 特点：逻辑相邻，物理不相邻 头结点：只在其指针域存放下一结点的地址，用于标记链表的起始（第一个有效数据节点的地址），不存数据。 头结点的空间：栈区或全局区 有效数据的空间：堆区 声明单链表结点类型 typedef struct LNode { int data;//数据域 struct LNode* next;//指针域 }LNode,* Linklist 操作 链表初始化 //链表初始化 void InitLinkList(Linklist plist) { assert(pli
数据结构——单链表操作（C语言实现）
(｡◕‿◕｡)
09-27 386
//单链表node #include"stdio.h" #include"stdlib.h" typedef struct link_node{ int info; struct link_node *next; }node; // 初始化 node *init(node *head) { head = (node *)malloc(sizeof(node)); he...
单链表 的基本操作 c语言实现
QianLXP的博客
01-07 386
链表的基本操作【c语言实现】 运行环境：Dev-C++ 5.11 以下为源码，如有不正确的地方欢迎指正！ #include #include #define FALSE 0  #define TRUE  1  typedef int Datatype; typedef struct Node{ Datatype data; struct Node *next; }Linkli
C语言链表深度解析：从基础到Linux内核实现
"C语言的链表基础知识，包括单链表和双链表的介绍，以及Linux内核链表的特殊性。" 链表是计算机科学中一种重要的数据结构，尤其在C语言中，它是实现复杂数据操作的基础。链表与数组不同，它不连续存储数据，而是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值