链表的c语言实现以及根据linux内核中链表的实现过程

最新推荐文章于 2024-03-06 09:45:29 发布
最新推荐文章于 2024-03-06 09:45:29 发布
阅读量4k 收藏 3
点赞数
分类专栏： 数据结构与算法 文章标签： linux内核 语言 list c struct module
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lickylin/article/details/8010618
版权 
 

链表，就是用一组任意的存储单元存储线性表元素的一种数据结构。链表又分为单链表、双向链表和循环链表等。

下面代码是链表的两种实现方式，其中方式一就是按照数据结构书中对链表的实现过程，而方式二是根据linux内核中关于链表的实现。两者的最大区别是方式一中数据是存储在链表结构中的，而方式二中，是在数据结构中包含链表结构的。个人更倾向于第二种实现方法。

链表在内核中的使用例子，在驱动层我们可以建立一个链表实现数据的收发：比如当出现硬件中断时，我们将接收到的数据存储在链表中，并唤醒一个等待队列；而应用层通过阻塞的方式调用ioctl，当链表为空时，则进行睡眠操作，当出现一个唤醒操作时则读取链表中存在的消息，并返回给应用层，让应用层再进行相应的处理。这是链表在驱动层中的一个应用例子。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdint.h>
#include<signal.h>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>
typedef int pri_spin_t;
pri_spin_t spin_flag = 1;
#define MAX_READ_ENTRY 10
typedef struct _listp
{
	struct _listp *next;
	struct _listp *prev;
	int data;
}LISTP;

void pri_spin_lock(pri_spin_t *flag)
{
	while(1)
	{
		if(*flag)
		{
			*flag = 0;
			return;
		}
	}
	
}

void pri_spin_unlock(pri_spin_t *flag)
{
	*flag = 1;
}



void init_list_head(LISTP *listp)
{
	listp->next = listp;
	listp->prev = listp;
}

void list_add(LISTP *list_head, LISTP *listp)
{

	list_head->next->prev = listp;
	listp->next = list_head->next;
	listp->prev = list_head;
	list_head->next = listp;
}
void list_add_tail(LISTP *list_head, LISTP *listp)
{
	list_head->prev->next = listp;
	listp->prev = list_head->prev;
	listp->next=list_head;
	list_head->prev = listp;

}

int list_is_empty(LISTP *list_head)
{
	return (list_head->next == list_head);
}

void list_del(LISTP *listp)
{
	LISTP *prev;
	LISTP *next;
	prev = listp->prev;
	next = listp->next;
	prev->next = next;
	next->prev = prev;
	
	listp->next = listp;
	listp->prev = listp;
}
void free_list(LISTP *list_head)
{
	LISTP *pos = NULL;
	pos = list_head->next;
	while(pos != list_head)
	{
		list_del(pos);
	        free(pos);
		pos = list_head->next;	
		printf("free\n");
	}
	
	if((list_head->next == list_head->prev)&&(list_head->next == list_head))
	{
		printf("list empty\n");
	}
	list_head->next = NULL;
	list_head->prev = NULL;

	free(list_head);
}
int add_data(int data, LISTP *list_head)
{
	LISTP *listp = NULL;

	listp = (LISTP *)malloc(sizeof(LISTP));
	if(listp == NULL)
	{
		printf("%s:Can not get memory\n", __FUNCTION__);
		return -1;
	}

	listp->data = data;
	list_add(list_head, listp);
	
}
int add_data_tail(int data, LISTP *list_head)
{
	LISTP *listp = NULL;

	listp = (LISTP *)malloc(sizeof(LISTP));
	if(listp == NULL)
	{
		printf("%s:Can not get memory\n", __FUNCTION__);
		return -1;
	}

	listp->data = data;
	list_add_tail(list_head, listp);
	
}
void print_data(LISTP *list_head)
{	
	int data;
	LISTP *pos;

	if(list_is_empty(list_head))
	{
		printf("list head is empty\n");
		return;
	}
	for(pos = list_head->next; pos != list_head;pos = pos->next)
	{
		if(pos)
		{
			if(pos->next == list_head)
				printf("%d\n", pos->data);
			else
				printf("%d\t", pos->data);
		}
	}	
}
void read_data(LISTP *list_head, int num)
{
	int data;
	LISTP *entry;

	if(list_is_empty(list_head))
	{
		printf("list head is empty\n");
		return;
	}
	
	if(num > MAX_READ_ENTRY)
	{
		num = MAX_READ_ENTRY;
	}
	printf("READ MESSAGE IS:\n");
	for(entry = list_head->next; (entry != list_head)&&(num > 0); entry = list_head->next)
	{
		printf("%d\t", entry->data);
		list_del(entry);
		entry->next = NULL;
		entry->prev = NULL;
		free(entry);
		num--;
	
	printf("\n");	
}

void *send_message_pth1(void *arg)
{
	int i = 0;
	while(1)
	{
		pri_spin_lock(&spin_flag);	
		add_data_tail(i, (LISTP *)arg);
		printf("-----IN SEND_MESSAGE_PTHREAD 1-----\n");
		pri_spin_unlock(&spin_flag);
		i++;
		sleep(2);	
	}
}
void *send_message_pth2(void *arg)
{
	int i = 0;
	while(1)
	{
		pri_spin_lock(&spin_flag);	
		add_data_tail(i, (LISTP *)arg);
                printf("-----IN SEND_MESSAGE_PTHREAD 2-----\n");
                pri_spin_unlock(&spin_flag);
		i++;
		sleep(2);	
	}
}
void *print_message_pth(void *arg)
{
	while(1)
	{

                pri_spin_lock(&spin_flag);
                printf("-----IN PRINT_MESSAGE_PTHREAD-----\n");
		print_data((LISTP *)arg);
		pri_spin_unlock(&spin_flag);
		sleep(2);
	}
}	

void *read_message_pth(void *arg)
{
	int num = 5;
	
	while(1)
	{
		pri_spin_lock(&spin_flag);
		printf("-----IN READ_MESSAGE_PTH-----\n");
		read_data((LISTP *)arg, num);
		pri_spin_unlock(&spin_flag);
		sleep(6);
	}
	
}
int main()
{
	int i = 0;
	LISTP *list_head = NULL;
	pthread_t pth1;
	pthread_t pth2;
	pthread_t pth3;
	pthread_t pth4;
	list_head = (LISTP *)malloc(sizeof(LISTP));
	if(list_head == NULL)
	{
		printf("Can not get memory\n");
		return -1;
	}
	init_list_head(list_head);

	/*store data into list_head*/
	for(i = 0; i < 10; i ++)
	{
		pri_spin_lock(&spin_flag);
		add_data_tail(i, list_head);
		pri_spin_unlock(&spin_flag);
	}


	if(pthread_create(&pth1, NULL, (void *)send_message_pth1, list_head))
	{
		printf("create pthread failed\n");
		return -1;
	}
	if(pthread_create(&pth2, NULL, (void *)send_message_pth2, list_head))
	{
		printf("create pthread failed\n");
		return -1;
	}
	if(pthread_create(&pth3, NULL, (void *)print_message_pth, list_head))
	{
		printf("create pthread failed\n");
		return -1;
	}
	if(pthread_create(&pth4, NULL, (void *)read_message_pth, list_head))
	{
		printf("create pthread failed\n");
		return -1;
	}
	while(1);
	return 0;
}


 

 

方式二：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdint.h>
#include<signal.h>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>
typedef int pri_spin_t;
#define MAX_READ_ENTRY 10
#define GET_ADDR_BY_OFFSET(ptr, type, member) ((type *)((char *)ptr - (uint32_t)(&(((type *)0)->member))))

typedef struct _listp
{
	struct _listp *next;
	struct _listp *prev;
}LISTP;

typedef struct _list_msg
{
	int data;
	LISTP list;
}LIST_MSG;

typedef struct _module_struct
{
	LISTP list_head;
	pri_spin_t spin_flag;
}MODULE_STRUCT;

void pri_spin_lock(pri_spin_t *flag)
{
	while(1)
	{
		if(*flag)
		{
			*flag = 0;
			return;
		}
	}
	
}

void pri_spin_unlock(pri_spin_t *flag)
{
	*flag = 1;
}



void init_list_head(LISTP *listp)
{
	listp->next = listp;
	listp->prev = listp;
}

void list_add(LISTP *list_head, LISTP *listp)
{

	list_head->next->prev = listp;
	listp->next = list_head->next;
	listp->prev = list_head;
	list_head->next = listp;
}
void list_add_tail(LISTP *list_head, LISTP *listp)
{
	list_head->prev->next = listp;
	listp->prev = list_head->prev;
	listp->next=list_head;
	list_head->prev = listp;

}

int list_is_empty(LISTP *list_head)
{
	return (list_head->next == list_head);
}

void list_del(LISTP *listp)
{
	LISTP *prev;
	LISTP *next;
	prev = listp->prev;
	next = listp->next;
	prev->next = next;
	next->prev = prev;
	
	listp->next = listp;
	listp->prev = listp;
}
void free_list(LISTP *list_head)
{
	LISTP *pos = NULL;
	pos = list_head->next;
	while(pos != list_head)
	{
		list_del(pos);
	        free(pos);
		pos = list_head->next;	
		printf("free\n");
	}
	
	if((list_head->next == list_head->prev)&&(list_head->next == list_head))
	{
		printf("list empty\n");
	}
	list_head->next = NULL;
	list_head->prev = NULL;

	free(list_head);
}
int add_data(int data, LISTP *list_head)
{
	LIST_MSG *list_message = NULL;

	list_message = (LIST_MSG *)malloc(sizeof(LIST_MSG));
	if(list_message == NULL)
	{
		printf("%s:Can not get memory\n", __FUNCTION__);
		return -1;
	}

	init_list_head(&(list_message->list));
	list_message->data = data;
	list_add(list_head, &(list_message->list));
	return 0;	
}
int add_data_tail(int data, LISTP *list_head)
{
	LIST_MSG *list_message = NULL;

	list_message = (LIST_MSG *)malloc(sizeof(LIST_MSG));
	if(list_message == NULL)
	{
		printf("%s:Can not get memory\n", __FUNCTION__);
		return -1;
	}
	init_list_head(&(list_message->list));
	
	list_message->data = data;
	list_add_tail(list_head, &(list_message->list));
	return 0;
}
void print_data(LISTP *list_head)
{	
	int data;
	LISTP *pos;
	LIST_MSG *message;

	if(list_is_empty(list_head))
	{
		printf("list head is empty\n");
		return;
	}


	for(pos = list_head->next; pos != list_head;pos = pos->next)
	{
		if(pos)
		{
			message = GET_ADDR_BY_OFFSET(pos, LIST_MSG, list);
			if(message)
			{
				printf("%d\t", message->data);
			}
		}
	}	
	printf("\n");
	
}
void read_data(LISTP *list_head, int num)
{
	int data;
	LISTP *entry;
	LIST_MSG *message;

	if(list_is_empty(list_head))
	{
		printf("list head is empty\n");
		return;
	}

	
	if(num > MAX_READ_ENTRY)
	{
		num = MAX_READ_ENTRY;
	}

	printf("READ MESSAGE IS:\n");

	for(entry = list_head->next; (entry != list_head)&&(num > 0); entry = list_head->next)
	{

		message = GET_ADDR_BY_OFFSET(entry, LIST_MSG, list);
		if(message)
		{
			printf("%d\t", message->data);
			list_del(&(message->list));
			free(message);
			num--;
		}
	}
	printf("\n");	
}

void *send_message_pth1(void *arg)
{
	int i = 0;
        MODULE_STRUCT *main_data;
	main_data = (MODULE_STRUCT *)arg;	
	while(1)
	{
		pri_spin_lock(&(main_data->spin_flag));
		add_data_tail(i, &(main_data->list_head));
		printf("-----IN SEND_MESSAGE_PTHREAD 1-----\n");
		pri_spin_unlock(&(main_data->spin_flag));
		i++;
		sleep(2);	
	}
}
void *send_message_pth2(void *arg)
{
	int i = 0;
        MODULE_STRUCT *main_data;
	main_data = (MODULE_STRUCT *)arg;	
	while(1)
	{
		pri_spin_lock(&(main_data->spin_flag));	
		add_data_tail(i, &(main_data->list_head));
                printf("-----IN SEND_MESSAGE_PTHREAD 2-----\n");
                pri_spin_unlock(&(main_data->spin_flag));
		i++;
		sleep(2);	
	}
}
void *print_message_pth(void *arg)
{
        MODULE_STRUCT *main_data;
	main_data = (MODULE_STRUCT *)arg;	
	while(1)
	{

                pri_spin_lock(&(main_data->spin_flag));
                printf("-----IN PRINT_MESSAGE_PTHREAD-----\n");
		print_data(&(main_data->list_head));
		pri_spin_unlock(&(main_data->spin_flag));
		sleep(2);
	}
}	

void *read_message_pth(void *arg)
{
	int num = 5;
        MODULE_STRUCT *main_data;
	main_data = (MODULE_STRUCT *)arg;	
	
	while(1)
	{
		pri_spin_lock(&(main_data->spin_flag));
		printf("-----IN READ_MESSAGE_PTH-----\n");
		read_data(&(main_data->list_head), num);
		pri_spin_unlock(&(main_data->spin_flag));
		sleep(3);
	}
	
}
int main()
{
	int i = 0;
	MODULE_STRUCT main_data;
	pthread_t pth1;
	pthread_t pth2;
	pthread_t pth3;
	pthread_t pth4;
	
	main_data.spin_flag = 1;
	init_list_head(&(main_data.list_head));
	for(i = 0; i < 10; i ++)
	{
		pri_spin_lock(&(main_data.spin_flag));
		add_data_tail(i, &(main_data.list_head));
		pri_spin_unlock(&(main_data.spin_flag));
	}

	if(pthread_create(&pth1, NULL, (void *)send_message_pth1, (void *)&main_data))
	{
		printf("create pthread failed\n");
		return -1;
	}
	if(pthread_create(&pth2, NULL, (void *)send_message_pth2, (void *)&main_data))
	{
		printf("create pthread failed\n");
		return -1;
	}
	if(pthread_create(&pth3, NULL, (void *)print_message_pth, (void *)&main_data))
	{
		printf("create pthread failed\n");
		return -1;
	}
	if(pthread_create(&pth4, NULL, (void *)read_message_pth, (void *)&main_data))
	{
		printf("create pthread failed\n");
		return -1;
	}
	while(1);
	return 0;
}


 

jerry_chg
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C：数据结构（内核链表）：Linux-Kernel-List （双向循环）
becky_lyl的博客
05-12 47
⑤LIST_POISON1/LIST_POISON2 这宏定义是在内核做标记用，被标记结点的前驱与后继等于内核特定地址，用户空间用的话一般删掉，用NULL替换。（这种下载的是当前系统所用到的系统源码版本，下载之后再 /usr/src中找到系统源码的压缩包解压到用的共享文件中）②WRITE_ONCE属于系统内核接口（在内核空间里使用），我吗应用层（用户空间）无法使用。⑥ 在623以后的出错是关于哈希表的，删掉至 #endif。④加入 stdbool.h。获取结构体变量的地址。
Linux内核中链表的实现
终身学习的程序猿
06-03 691
前言 曾经写过一篇《Linux内核中链表的使用》， 这篇文章只是参考LKD3e介绍了内核中链表的使用方法，并没详细介绍链表的具体实现和该链表的组织方式，本文将更深入学习内核中的链表相关的知识，并解答上述问题。 传统双向链表和内核中的双向链表的区别 Linux内核中实现的链表，和平时看到的链表不太一样，它不是把具体的数据结构塞入到链表中，而是把链表节点存放到用户的数据结构中。这个设计的主要目的是因为...
linux c语言实现链表
qq_57018268的博客
07-28 711
代码】linuxc语言实现链表。
linux 内核链表的实现
Louis@L.M.的博客
01-18 1135
    相比于普遍的链表实现方式，linux内核链表的实现方式可以说独树一帜。普遍的链表实现方式是在数据结构中嵌入链表指针，而linux内核链表的实现方式是将链表结点塞进数据结构里。 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变...
LINUX内核链表
Jaylen.sun的嵌入式之旅
02-15 787
Linux 内核链表的思路把传统链表中的“链”抽象出来，使之成为一条只包含前后指针的纯粹的双循环链表，这样的链表由于不含有特殊的数据，因此它实质上就是链表的抽象表示，类似于一条通用的绳子，在实际应用中只需将这条绳子“嵌入”一个具体的节点当中
linux内核数据结构之链表
weixin_33832340的博客
12-15 143
1、前言 　　 最近写代码需用到链表结构，正好公共库有关于链表的。第一眼看时，觉得有点新鲜，和我之前见到的链表结构不一样，只有前驱和后继指针，而没有数据域。后来看代码注释发现该代码来自linux内核，在linux源代码下include/Lish.h下。这个链表具备通用性，使用非常方便。只需要在结构定义一个链表结构就可以使用。 2、链表介绍 　　链表是非常基本的数据结构，根据链个数分为单链表、...
链表的C语言实现
Jamza的博客
07-18 495
链表 链表由一组元素，以一种特定的顺序组合或者链接在一起 相对数组，链表在执行插入、删除操作时具有更高的效率 链表需要动态的开辟存储空间，也就是存储空间在程序运行时是动态分配的 链表类型：单向链表、双向链表、循环链表 单向链表 list_init void list_init(List *list, void (*destroy)(void *data)); /* 初始化由参数list指定的链表 参数destroy为函数指针，提供了一种释放动态分配数据的方法 */ list_destroy void li
c语言是如何实现泛型链表
07-17
在Linux内核源码中，list_head结构体被广泛使用来实现泛型链表。这是因为内核需要处理各种各样的数据类型，并且要求运行效率高，所以需要一种通用的链表结构来减少代码的重复编写并提高性能。Linux内核的泛型链表是...
基于c语言和Linux内核链表的贪吃蛇小游戏
04-16
贪吃蛇小游戏，用c语言和Linux内核链表实现，图行显示基于curses库，游戏界面有时钟计时器和当前分数、上一次游戏分数、历史最高分数显示。
linux内核链表测试用例
05-31
在Linux操作系统中，内核链表是一种非常基础且重要的数据结构，它被广泛用于系统内核中的各种数据管理。这个“linux内核链表测试用例”是一个演示如何在实际编程中应用这些链表的实例。下面我们将深入探讨Linux内核...
Linux内核的纯链表代码
02-23
该文件为Linux纯链表的包含文件，为Linux内核的原始代码，部分讲解在我的博客中。可用于学习C指针，链表。配上博客地址：https://blog.csdn.net/weixin_44313435/article/details/104457115
Linux操作系统中通用双向循环链表的实现分析.pdf
09-06
在Linux内核中，定义了一个通用的双向循环链表对象list-head，该对象的定义主要在list.h文件中实现。list-head是一个结构类型，其中包含两个指针域：next指向本结点在双向循环链表中的后继结点，prey指向前驱结点。...
C语言——内核链表
LoyKevin的博客
07-21 534
内核链表 内核链表的节点 struct list_head{ struct list_head * next, *prev; }; 被管理的数据 struct stu{ int age; struct list_head * mbr; }; 相关的操作接口 1. 初始化内核链表 struct list_head { struct list_head *next, *prev; }; //方法一： #define LIST_HEAD_INIT(name) { &(name), &
Linux内核--链表的实现方式详解
最新发布
MHD0815的博客
03-06 469
总之，Linux内核链表的实现是基于双向链表结构，并使用一系列宏和函数来简化和优化链表操作。Linux内核中的链表操作不是线程安全的，也就是说，在并发环境下使用链表时，需要额外的同步机制（如自旋锁）来确保操作的原子性。内核链表实现通常经过优化，以最小化内存使用和CPU开销，这对于内核代码来说是非常重要的，因为它直接影响了系统的整体性能。Linux内核中的链表是基于双向链表的，每个链表节点都包含两个指针，一个指向前一个节点（这样，链表节点可以携带额外的数据，并且可以通过链表节点来访问这些数据。
【Linux内核链表】的原理及使用方式整理
weixin_37620587的博客
04-02 1073
内核的双链表原理以及使用方式，包括内核的链表宏解释
【linux内核】链表
qq_42427720的博客
12-18 118
重点介绍linux使用的链表，其他几种看图简单理解，linux 链表采用数据和链表分开形式的环形双向链表。本次实验采用linux下模块注册的形式进行，注册后会把链表数据打印到终端。单向链表双向链表环形链表。
Linux内核入门:内核中常用的数据结构和算法
qq_52267946的博客
01-21 1009
/红黑树节点//左孩子//右孩子//父节点颜色以及其他信息//...// 红黑树根节点}rb_root;int key;int data;}mytype;//根节点rb_subtree_last:指向当前节点的右子树的最后一个节点rb_left:指向当前节点的左子结点rb_right:指向当前节点的右子节点rb_parent_color:保存父节点的地址和颜色信息.其中,最低位表示节点颜色(RB_RED/RB_BLACK)
linux内核链表的实现和使用和详解
zz460833359的博客
07-12 889
首先，内核链表的头文件，在linux内核的 /include/linux 下的 List.h ，把List.h 复制出来，黏贴到 工程下，就可以直接用内核链表的一些宏和函数。 以下介绍内核链表的一些宏和函数，已经他的实现方式和使用方法。 （1）什么是内核链表： 如图：内核链表一般就是 在一个结构体 有一个结构体成员变量，该结构体成员变量只有 next 和 prev两个指针，分别指向下一个结点和上一个结构，就像一条绳子串起所有的结构体，这样做的好处，就是可以用内核链表来串起各个不同类型的结构体。 （2
冒泡排序算法的c语言实现
lickylin的专栏
09-23 7083
冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。 在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2
请用c语言实现，Linux内核链表，并按照Linux内核代码风格
05-31
Linux内核链表是一个非常常用的数据结构，可以用来实现各种链式数据结构，比如队列、堆栈等。下面是一个简单的实现： ```c #include <linux/list.h> struct my_node { int value; struct list_head list; }; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值