首页 > 其他分享 >14.2 并发与竞争实验

14.2 并发与竞争实验

时间：2023-08-24 16:36:34浏览次数：34  
标签：led 14.2 LED return 并发 实验 gpio 设备 gpioled

一、原子操作实验

  这节使用原子操作来实现对 LED 设备的互斥访问，也就是只有一个应用程序能使用 LED。

 

1. 实验程序编写

  因为是 12 章已经修改了设备树，所以这里暂时不用修改。

  在 /linux/atk-mpl/Drivers 该目录下创建 7_atomic 子目录，并且把 5_gpioled 里面的 gpioled.c 文件复制到 7_atomic 子目录下并重命名为 atomic.c，还在改子目录下创建 Vscode 工作区。首先先编写 atomic.c 程序：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT			1		  	/* 设备号个数 */
#define GPIOLED_NAME		"gpioled"	/* 名字 */
#define LEDOFF 				0			/* 关灯 */
#define LEDON 				1			/* 开灯 */

/* gpioled设备结构体 */
struct gpioled_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
	int led_gpio;			/* led所使用的GPIO编号 */       // 此成员变量保存 LED 等所使用的 GPIO 编号
	atomic_t lock; 			// 原子变量
};

struct gpioled_dev gpioled;	/* led设备 */

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
	/* 通过判断原子变量的值来检查LED有没有被别的应用使用 */
	if (!atomic_dec_and_test(&gpioled.lock))		// 给lock减１，如果结果为０返回真否则为假，这里用了取反，所以这里是不为０为真，这里只有１和０，减一说明要么０要么－１，这里判断lock为－１才往下走
	{												// 相反，lock为１，减一后为０，条件不满足不执行，这就是判断依据
		atomic_inc(&gpioled.lock);	// 给lock加１	/* 小于0的话就加1,使其原子变量等于0 */
		retrun -EBUSY;	/* LED被使用，返回忙 */
	}
	

	filp->private_data = &gpioled; /* 设置私有数据 */
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;
	struct gpioled_dev *dev = filp->private_data;   // 通过读取 filp 的 private_data 成员变量来得到设备结构体变量

	retvalue = copy_from_user(databuf, buf, cnt); /* 接收APP发送过来的数据 */
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

    /* 调用 gpio_set_value 函数来向 GPIO 写入数据，实现开/关 LED 的效果。不需要直接操作相应的寄存器 */
	if(ledstat == LEDON) {	
		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
	}
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int led_release(struct inode *inode, struct file *filp)
{
	struct gpioled_dev *dev = filp->private_data;	// 新加的，这里把私有数据给dev

	/* 关闭驱动文件的时候释放原子变量 */
	atomic_inc(&dev->lock);

	return 0;
}

/* 设备操作函数 */
static struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init led_init(void)
{
	int ret = 0;
	const char *str;

	// 1、初始化原子变量
	gpioled.lock = (atomic_t)ATOMIC_INIT(0);

	// 2、原子变量初始化为１
	atomic_set(&gpioled.lock, 1);

	/* 设置LED所使用的GPIO */
	/* 1、获取设备节点：gpioled */
	gpioled.nd = of_find_node_by_path("/gpioled");
	if(gpioled.nd == NULL) {
		printk("gpioled node not find!\r\n");
		return -EINVAL;
	}

	/* 2.读取status属性 */
	ret = of_property_read_string(gpioled.nd, "status", &str);      // 获取状态是否是"okay"
	if(ret < 0) 
	    return -EINVAL;

	if (strcmp(str, "okay"))
        return -EINVAL;
    
	/* 3、获取compatible属性值并进行匹配 */
	ret = of_property_read_string(gpioled.nd, "compatible", &str);
	if(ret < 0) {
		printk("gpioled: Failed to get compatible property\n");
		return -EINVAL;
	}

    if (strcmp(str, "alientek,led")) {
        printk("gpioled: Compatible match failed\n");
        return -EINVAL;
    }

	/* 4、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);    // 获取 LED 所使用的 LED 编号。相当于将 gpioled 节点中的“led-gpio”属性值转换为对应的 LED 编号
	if(gpioled.led_gpio < 0) {
		printk("can't get led-gpio");
		return -EINVAL;
	}
	printk("led-gpio num = %d\r\n", gpioled.led_gpio);

	/* 5.向gpio子系统申请使用GPIO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");       // 这里设备树已经改成了led-gpio=<&gpioi 0 GPIO_ACTIVE_LOW>
    if (ret) {
        printk(KERN_ERR "gpioled: Failed to request led-gpio\n");
        return ret;
	}

	/* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */
	ret = gpio_direction_output(gpioled.led_gpio, 1);
	if(ret < 0) {
		printk("can't set gpio!\r\n");
	}

	/* 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (gpioled.major) {		/*  定义了设备号 */
		gpioled.devid = MKDEV(gpioled.major, 0);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
		if(ret < 0) {
			pr_err("cannot register %s char driver [ret=%d]\n", GPIOLED_NAME, GPIOLED_CNT);
			goto free_gpio;
		}
	} else {						/* 没有定义设备号 */
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
		if(ret < 0) {
			pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", GPIOLED_NAME, ret);
			goto free_gpio;
		}
		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
	}
	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
	
	/* 2、初始化cdev */
	gpioled.cdev.owner = THIS_MODULE;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
	if(ret < 0)
		goto del_unregister;
		
	/* 4、创建类 */
	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
	if (IS_ERR(gpioled.class)) {
		goto del_cdev;
	}

	/* 5、创建设备 */
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
	if (IS_ERR(gpioled.device)) {
		goto destroy_class;
	}
	return 0;
	
destroy_class:
	class_destroy(gpioled.class);
del_cdev:
	cdev_del(&gpioled.cdev);
del_unregister:
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);
free_gpio:
	gpio_free(gpioled.led_gpio);
	return -EIO;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit led_exit(void)
{
	/* 注销字符设备驱动 */
	cdev_del(&gpioled.cdev);/*  删除cdev */
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
	device_destroy(gpioled.class, gpioled.devid);/* 注销设备 */
	class_destroy(gpioled.class);/* 注销类 */
	gpio_free(gpioled.led_gpio); /* 释放GPIO */
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");

  其次编写 atomicApp.c 测试文件：

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

#define LEDOFF 	0
#define LEDON 	1

/*
 * @description		: main主程序
 * @param - argc 	: argv数组元素个数
 * @param - argv 	: 具体参数
 * @return 			: 0 成功;其他 失败
 */
int main(int argc, char *argv[])
{
	int fd, retvalue;
	char *filename;
	unsigned char cnt = 0;
	unsigned char databuf[1];
	
	if(argc != 3){
		printf("Error Usage!\r\n");
		return -1;
	}

	filename = argv[1];

	/* 打开led驱动 */
	fd = open(filename, O_RDWR);
	if(fd < 0){
		printf("file %s open failed!\r\n", argv[1]);
		return -1;
	}

	databuf[0] = atoi(argv[2]);	/* 要执行的操作：打开或关闭 */

	/* 向/dev/gpioled文件写入数据 */
	retvalue = write(fd, databuf, sizeof(databuf));
	if(retvalue < 0){
		printf("LED Control Failed!\r\n");
		close(fd);
		return -1;
	}

	/* 模拟占用25S LED */
	while(1) {
		sleep(5);
		cnt++;
		printf("App running times:%d\r\n", cnt);
		if(cnt >= 5) break;
	}

	printf("App running finished!");
	retvalue = close(fd); /* 关闭文件 */
	if(retvalue < 0){
		printf("file %s close failed!\r\n", argv[1]);
		return -1;
	}
	return 0;
}

 

2. 运行测试

  编写 Makefile 文件：

KERNELDIR := /home/alientek/linux/atk-mpl/linux/my_linux/linux-5.4.31	# Linux内核源码路径
CURRENT_PATH := $(shell pwd)

obj-m := atomic.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules

clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

  编译 Makefile 文件得到 atomic.ko 文件。

make

  编译 atomicApp.c 文件得到 atomicApp 文件。

arm-none-linux-gnueabihf-gcc atomicApp.c -o atomicApp

  将这两个文件拷贝：

sudo cp atomicApp atomic.ko /home/alientek/linux/nfs/rootfs/lib/modules/5.4.31/

  开启开发板，输入命令加载 atomic.ko 驱动：

depmod
modprobe atomic.ko

 

  输入命令开启 LED，并且每隔 5s 都会输出 App running times：

./atomicApp /dev/gpioled 1&    # “&”表示在后台运行 atomicApp 这个软件

 

  当在运行过程中输入以下命令的时候：

/atomicApp /dev/gpioled 0     # 关闭 LED 灯

  打开 /dev/gpioled 失败，原因是 atomicApp 软件正在占用 /dev/gpioled，如果再次运行 atomicApp 软件去操作/dev/gpioled 肯定会失败。必须等待 atomicApp运行结束，也就是25S结束以后其他软件才能去操作/dev/gpioled。这个就是采用原子变量实现一次只能有一个应用程序访问 LED 灯。 

  最后卸载驱动：

rmmod atomic.ko

 

二、自旋锁实验

  上节是使用原子操作实现一个应用程序访问 LED，这次换成自旋锁实现。

  首先先注意自旋锁使用事项：

  ① 自旋锁保护的临界区尽可能的短。使用一个变量来表示设备的使用情况，如果设备被使用了那么变量就加一，设备被释放以后变量就减 1，我们只需要使用自旋锁保护这个变量即可。

  ② 考虑驱动兼容性，选择合理的 API 函数。

 

1. 实验程序编写

  不用修改设备树。

  把上一节的 atomic.c、Makefiel、atomicApp.c 复制到新的子目录 8_spinlock 中，并把 atomic 相关的重命名为 spinlock，首先修改 spinlock.c 文件：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT			1		  	/* 设备号个数 */
#define GPIOLED_NAME		"gpioled"	/* 名字 */
#define LEDOFF 				0			/* 关灯 */
#define LEDON 				1			/* 开灯 */

/* gpioled设备结构体 */
struct gpioled_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
	int led_gpio;			/* led所使用的GPIO编号 */       // 此成员变量保存 LED 等所使用的 GPIO 编号
	int dev_stats;			// 设备使用状态 0设备未使用　>0设备使用
	spinlock_t lock;		// 自旋锁
};

struct gpioled_dev gpioled;	/* led设备 */

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
	unsigned long flags;	//　中断状态变量
	filp->private_data = &gpioled; /* 设置私有数据 */

	spin_lock_irqsave(&gpioled.lock, flags);	// 保存中断状态，禁止本地中断，并获取自旋锁；这里为什么没有使用spin_lock就是考虑到兼容性
	if (gpioled.dev_stats)		// 如果设备被使用
	{
		spin_unlock_irqrestore(&gpioled.lock, flags);	// 将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁
		return -EBUSY;
	}
	gpioled.dev_stats++;	// 如果设备没有使用，就让stats > 0使其使用变为使用中
	spin_unlock_irqrestore(&gpioled.lock, flags);	// 解锁

	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;
	struct gpioled_dev *dev = filp->private_data;   // 通过读取 filp 的 private_data 成员变量来得到设备结构体变量

	retvalue = copy_from_user(databuf, buf, cnt); /* 接收APP发送过来的数据 */
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

    /* 调用 gpio_set_value 函数来向 GPIO 写入数据，实现开/关 LED 的效果。不需要直接操作相应的寄存器 */
	if(ledstat == LEDON) {	
		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
	}
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int led_release(struct inode *inode, struct file *filp)
{
	unsigned long flags;
	struct gpioled_dev *dev = filp->private_data;	// 新加的，这里把私有数据给dev

	/* 关闭驱动文件的时候将dev_stats减1 */
	spin_lock_irqsave(&dev->lock, flags);	// 上锁
	if (dev->dev_stats)		// dev_stats 为１成立，设备使用中
	{
		dev->dev_stats --;	// dev_stats 为０，释放设备
	}
	spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */

	return 0;
}
// 这里有个疑惑为什么oepn和release都要有上锁和解锁，是因为确保在同一时间只有一个进程能改变dev_stats的值，可以防止竞争的发生

/* 设备操作函数 */
static struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init led_init(void)
{
	int ret = 0;
	const char *str;

	// 自旋锁初始化
	spin_lock_init(&gpioled.lock);
	
	/* 设置LED所使用的GPIO */
	/* 1、获取设备节点：gpioled */
	gpioled.nd = of_find_node_by_path("/gpioled");
	if(gpioled.nd == NULL) {
		printk("gpioled node not find!\r\n");
		return -EINVAL;
	}

	/* 2.读取status属性 */
	ret = of_property_read_string(gpioled.nd, "status", &str);      // 获取状态是否是"okay"
	if(ret < 0) 
	    return -EINVAL;

	if (strcmp(str, "okay"))
        return -EINVAL;
    
	/* 3、获取compatible属性值并进行匹配 */
	ret = of_property_read_string(gpioled.nd, "compatible", &str);
	if(ret < 0) {
		printk("gpioled: Failed to get compatible property\n");
		return -EINVAL;
	}

    if (strcmp(str, "alientek,led")) {
        printk("gpioled: Compatible match failed\n");
        return -EINVAL;
    }

	/* 4、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);    // 获取 LED 所使用的 LED 编号。相当于将 gpioled 节点中的“led-gpio”属性值转换为对应的 LED 编号
	if(gpioled.led_gpio < 0) {
		printk("can't get led-gpio");
		return -EINVAL;
	}
	printk("led-gpio num = %d\r\n", gpioled.led_gpio);

	/* 5.向gpio子系统申请使用GPIO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");       // 这里设备树已经改成了led-gpio=<&gpioi 0 GPIO_ACTIVE_LOW>
    if (ret) {
        printk(KERN_ERR "gpioled: Failed to request led-gpio\n");
        return ret;
	}

	/* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */
	ret = gpio_direction_output(gpioled.led_gpio, 1);
	if(ret < 0) {
		printk("can't set gpio!\r\n");
	}

	/* 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (gpioled.major) {		/*  定义了设备号 */
		gpioled.devid = MKDEV(gpioled.major, 0);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
		if(ret < 0) {
			pr_err("cannot register %s char driver [ret=%d]\n", GPIOLED_NAME, GPIOLED_CNT);
			goto free_gpio;
		}
	} else {						/* 没有定义设备号 */
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
		if(ret < 0) {
			pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", GPIOLED_NAME, ret);
			goto free_gpio;
		}
		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
	}
	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
	
	/* 2、初始化cdev */
	gpioled.cdev.owner = THIS_MODULE;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
	if(ret < 0)
		goto del_unregister;
		
	/* 4、创建类 */
	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
	if (IS_ERR(gpioled.class)) {
		goto del_cdev;
	}

	/* 5、创建设备 */
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
	if (IS_ERR(gpioled.device)) {
		goto destroy_class;
	}
	return 0;
	
destroy_class:
	class_destroy(gpioled.class);
del_cdev:
	cdev_del(&gpioled.cdev);
del_unregister:
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);
free_gpio:
	gpio_free(gpioled.led_gpio);
	return -EIO;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit led_exit(void)
{
	/* 注销字符设备驱动 */
	cdev_del(&gpioled.cdev);/*  删除cdev */
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
	device_destroy(gpioled.class, gpioled.devid);/* 注销设备 */
	class_destroy(gpioled.class);/* 注销类 */
	gpio_free(gpioled.led_gpio); /* 释放GPIO */
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");

  测试 APP 跟上节一样，把名字变成 spinlockApp.c 即可。 

 

2. 运行测试

  修改 Makefile 中的 ，改为 spinlock.o 即可。

  编译 spinlock.c 文件：

make

  编译 spinlockApp.c 文件：

arm-none-linux-gnueabihf-gcc spinlockApp.c -o spinlockApp

  把以上两个文件复制：

sudo cp spinlockApp spinlock.ko /home/alientek/linux/nfs/rootfs/lib/modules/5.4.31/

  开启开发板，输入以下命令：

cd lib/modules/5.4.31/
depmod
modprobe spinlock.ko

  使用 spinlockApp 进行测试驱动：

./spinlockApp /dev/gpioled 1&     // 打开 LED 灯
./spinlockApp /dev/gpioled 0      // 关闭 LED 灯

  驱动正常工作的话不会立马关闭 LED，会提示 file /dev/gpioled open failed!，必须等待第一个 spinlock App 软件运行完成才可以关闭。

  卸载驱动：

rmmod spinlock.ko

 

三、信号量实验

  使用信号量来实现只能有一个应用程序访问 LED，因为信号量可以导致休眠，所以信号量保护的临界区没有运行时间限制，就可以在 open 函数申请信号量，在 release 函数中释放信号量。

 

1. 实验程序编写

  不用修改设备树。

  新建 9_semaphore 文件夹，并按上一小节这样操作，只需要把 spinlock 改为 semaphore 即可。修改 semaphore.c 文件：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT			1		  	/* 设备号个数 */
#define GPIOLED_NAME		"gpioled"	/* 名字 */
#define LEDOFF 				0			/* 关灯 */
#define LEDON 				1			/* 开灯 */

/* gpioled设备结构体 */
struct gpioled_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
	int led_gpio;			/* led所使用的GPIO编号 */       // 此成员变量保存 LED 等所使用的 GPIO 编号
	struct semaphore sem;	// 信号量
};

struct gpioled_dev gpioled;	/* led设备 */

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &gpioled; /* 设置私有数据 */

	if (down_interruptible(&gpioled.sem));	// 获取信号量,进入休眠以后是可以被信号打断的,这时候count为0
	{
		return -ERESTARTSYS;
	}

/*	
  down(&gpioled.sem);	// 获取信号量，不能被信号打断
*/
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;
	struct gpioled_dev *dev = filp->private_data;   // 通过读取 filp 的 private_data 成员变量来得到设备结构体变量

	retvalue = copy_from_user(databuf, buf, cnt); /* 接收APP发送过来的数据 */
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

    /* 调用 gpio_set_value 函数来向 GPIO 写入数据，实现开/关 LED 的效果。不需要直接操作相应的寄存器 */
	if(ledstat == LEDON) {	
		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
	}
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int led_release(struct inode *inode, struct file *filp)
{
	struct gpioled_dev *dev = filp->private_data;	// 这里把私有数据给dev

	up(&dev->sem);		// 释放信号量，信号量count值加1
	return 0;
}


/* 设备操作函数 */
static struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init led_init(void)
{
	int ret = 0;
	const char *str;

	/* 初始化信号量 */
	sema_init(&gpioled.sem, 1);
	
	/* 设置LED所使用的GPIO */
	/* 1、获取设备节点：gpioled */
	gpioled.nd = of_find_node_by_path("/gpioled");
	if(gpioled.nd == NULL) {
		printk("gpioled node not find!\r\n");
		return -EINVAL;
	}

	/* 2.读取status属性 */
	ret = of_property_read_string(gpioled.nd, "status", &str);      // 获取状态是否是"okay"
	if(ret < 0) 
	    return -EINVAL;

	if (strcmp(str, "okay"))
        return -EINVAL;
    
	/* 3、获取compatible属性值并进行匹配 */
	ret = of_property_read_string(gpioled.nd, "compatible", &str);
	if(ret < 0) {
		printk("gpioled: Failed to get compatible property\n");
		return -EINVAL;
	}

    if (strcmp(str, "alientek,led")) {
        printk("gpioled: Compatible match failed\n");
        return -EINVAL;
    }

	/* 4、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);    // 获取 LED 所使用的 LED 编号。相当于将 gpioled 节点中的“led-gpio”属性值转换为对应的 LED 编号
	if(gpioled.led_gpio < 0) {
		printk("can't get led-gpio");
		return -EINVAL;
	}
	printk("led-gpio num = %d\r\n", gpioled.led_gpio);

	/* 5.向gpio子系统申请使用GPIO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");       // 这里设备树已经改成了led-gpio=<&gpioi 0 GPIO_ACTIVE_LOW>
    if (ret) {
        printk(KERN_ERR "gpioled: Failed to request led-gpio\n");
        return ret;
	}

	/* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */
	ret = gpio_direction_output(gpioled.led_gpio, 1);
	if(ret < 0) {
		printk("can't set gpio!\r\n");
	}

	/* 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (gpioled.major) {		/*  定义了设备号 */
		gpioled.devid = MKDEV(gpioled.major, 0);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
		if(ret < 0) {
			pr_err("cannot register %s char driver [ret=%d]\n", GPIOLED_NAME, GPIOLED_CNT);
			goto free_gpio;
		}
	} else {						/* 没有定义设备号 */
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
		if(ret < 0) {
			pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", GPIOLED_NAME, ret);
			goto free_gpio;
		}
		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
	}
	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
	
	/* 2、初始化cdev */
	gpioled.cdev.owner = THIS_MODULE;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
	if(ret < 0)
		goto del_unregister;
		
	/* 4、创建类 */
	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
	if (IS_ERR(gpioled.class)) {
		goto del_cdev;
	}

	/* 5、创建设备 */
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
	if (IS_ERR(gpioled.device)) {
		goto destroy_class;
	}
	return 0;
	
destroy_class:
	class_destroy(gpioled.class);
del_cdev:
	cdev_del(&gpioled.cdev);
del_unregister:
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);
free_gpio:
	gpio_free(gpioled.led_gpio);
	return -EIO;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit led_exit(void)
{
	/* 注销字符设备驱动 */
	cdev_del(&gpioled.cdev);/*  删除cdev */
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
	device_destroy(gpioled.class, gpioled.devid);/* 注销设备 */
	class_destroy(gpioled.class);/* 注销类 */
	gpio_free(gpioled.led_gpio); /* 释放GPIO */
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");

  当信号量 sem 为 1 的时候表示 LED 灯还没有被使用，如果应用程序 A 要使用LED 灯，先调用 open 函数打开/dev/gpioled，这个时候会获取信号量 sem，获取成功以后 sem 的值减 1 变为 0。如果此时应用程序 B 也要使用 LED 灯，调用 open 函数打开/dev/gpioled 就会因为信号量无效(值为 0)而进入休眠状态。当应用程序 A 运行完毕，调用 close 函数关闭/dev/gpioled的时候就会释放信号量 sem，此时信号量 sem 的值就会加 1，变为 1。信号量 sem 再次有效，表示其他应用程序可以使用 LED 灯了，此时在休眠状态的应用程序 B 就会获取到信号量 sem，获取成功以后就开始使用 LED 灯。 

 

2. 运行测试

  修改 Makefile 文件，跟上节一样，只不过改为 obj-m := semaphore.o。

  编译 semaphore.c 文件：

make

  编译 semaphoreApp.c 文件：

arm-none-linux-gnueabihf-gcc semaphoreApp.c -o semaphoreApp

  最后将以上两个文件复制：

sudo cp semaphoreApp semaphore.ko /home/alientek/linux/nfs/rootfs/lib/modules/5.4.31/

   开启开发板，加载驱动：

depmod
modprobe semaphore.ko

  驱动加载完成使用 semaphoreApp 测试驱动：

./semaphoreApp /dev/gpioled 1&  # 打开 LED 灯
./semaphoreApp /dev/gpioled 0&  # 关闭 LED 灯

  首先，第一条命令先获取信号量，因此可以操作 LED，所以这时候开发板上面的 LED 是亮着的。第二条命令因为也想获得 LED 使用权，但是被第一条命令抢先了，所以第二条命令就休眠，等到第一条命令完成的时候，释放信号量，第二条命令才能拥有 LED 使用权，这时候发现开发板的 LED 是灭的。总共开发板前 25s 亮，后 25s 灭。

  卸载驱动：

rmmod semaphore.ko

 

四、互斥体实验

  其实最适合互斥的就是互斥体 mutex。怎么感觉在说废话。

 

1. 实验程序编写

  不用修改设备树。

  跟上节一样的操作，全部改为 mutex。对了，每次记得添加头文件路径，修改 mutex.c 文件：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT			1		  	/* 设备号个数 */
#define GPIOLED_NAME		"gpioled"	/* 名字 */
#define LEDOFF 				0			/* 关灯 */
#define LEDON 				1			/* 开灯 */

/* gpioled设备结构体 */
struct gpioled_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
	int led_gpio;			/* led所使用的GPIO编号 */       // 此成员变量保存 LED 等所使用的 GPIO 编号
	struct mutex lock;		// 定义互斥体
};

struct gpioled_dev gpioled;	/* led设备 */

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &gpioled; /* 设置私有数据 */

	if (mutex_lock_interruptible(&gpioled.lock))		// 获取互斥体，可以被信号打断
	{
		return -ERESTARTSYS;
	}
	

/*	
	mutex_lock(&gpioled.lock);	// 获取信号量，不能被信号打断
*/
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;
	struct gpioled_dev *dev = filp->private_data;   // 通过读取 filp 的 private_data 成员变量来得到设备结构体变量

	retvalue = copy_from_user(databuf, buf, cnt); /* 接收APP发送过来的数据 */
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

    /* 调用 gpio_set_value 函数来向 GPIO 写入数据，实现开/关 LED 的效果。不需要直接操作相应的寄存器 */
	if(ledstat == LEDON) {	
		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
	}
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int led_release(struct inode *inode, struct file *filp)
{
	struct gpioled_dev *dev = filp->private_data;	// 这里把私有数据给dev

	mutex_unlock(&dev->lock);		// 释放互斥锁
	return 0;
}


/* 设备操作函数 */
static struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init led_init(void)
{
	int ret = 0;
	const char *str;

	/* 初始化互斥体 */
	mutex_init(&gpioled.lock);
	
	/* 设置LED所使用的GPIO */
	/* 1、获取设备节点：gpioled */
	gpioled.nd = of_find_node_by_path("/gpioled");
	if(gpioled.nd == NULL) {
		printk("gpioled node not find!\r\n");
		return -EINVAL;
	}

	/* 2.读取status属性 */
	ret = of_property_read_string(gpioled.nd, "status", &str);      // 获取状态是否是"okay"
	if(ret < 0) 
	    return -EINVAL;

	if (strcmp(str, "okay"))
        return -EINVAL;
    
	/* 3、获取compatible属性值并进行匹配 */
	ret = of_property_read_string(gpioled.nd, "compatible", &str);
	if(ret < 0) {
		printk("gpioled: Failed to get compatible property\n");
		return -EINVAL;
	}

    if (strcmp(str, "alientek,led")) {
        printk("gpioled: Compatible match failed\n");
        return -EINVAL;
    }

	/* 4、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);    // 获取 LED 所使用的 LED 编号。相当于将 gpioled 节点中的“led-gpio”属性值转换为对应的 LED 编号
	if(gpioled.led_gpio < 0) {
		printk("can't get led-gpio");
		return -EINVAL;
	}
	printk("led-gpio num = %d\r\n", gpioled.led_gpio);

	/* 5.向gpio子系统申请使用GPIO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");       // 这里设备树已经改成了led-gpio=<&gpioi 0 GPIO_ACTIVE_LOW>
    if (ret) {
        printk(KERN_ERR "gpioled: Failed to request led-gpio\n");
        return ret;
	}

	/* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */
	ret = gpio_direction_output(gpioled.led_gpio, 1);
	if(ret < 0) {
		printk("can't set gpio!\r\n");
	}

	/* 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (gpioled.major) {		/*  定义了设备号 */
		gpioled.devid = MKDEV(gpioled.major, 0);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
		if(ret < 0) {
			pr_err("cannot register %s char driver [ret=%d]\n", GPIOLED_NAME, GPIOLED_CNT);
			goto free_gpio;
		}
	} else {						/* 没有定义设备号 */
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
		if(ret < 0) {
			pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", GPIOLED_NAME, ret);
			goto free_gpio;
		}
		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
	}
	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
	
	/* 2、初始化cdev */
	gpioled.cdev.owner = THIS_MODULE;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
	if(ret < 0)
		goto del_unregister;
		
	/* 4、创建类 */
	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
	if (IS_ERR(gpioled.class)) {
		goto del_cdev;
	}

	/* 5、创建设备 */
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
	if (IS_ERR(gpioled.device)) {
		goto destroy_class;
	}
	return 0;
	
destroy_class:
	class_destroy(gpioled.class);
del_cdev:
	cdev_del(&gpioled.cdev);
del_unregister:
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);
free_gpio:
	gpio_free(gpioled.led_gpio);
	return -EIO;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit led_exit(void)
{
	/* 注销字符设备驱动 */
	cdev_del(&gpioled.cdev);/*  删除cdev */
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
	device_destroy(gpioled.class, gpioled.devid);/* 注销设备 */
	class_destroy(gpioled.class);/* 注销类 */
	gpio_free(gpioled.led_gpio); /* 释放GPIO */
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");

 

2. 运行测试

  修改 Makefile ，mutex.o。

  编译 mutex.c 文件和 mutexApp.c 文件：

make
arm-none-linux-gnueabihf-gcc mutexApp.c -o mutexApp

  上面两个文件复制到： 

sudo cp mutexApp mutex.ko /home/alientek/linux/nfs/rootfs/lib/modules/5.4.31/

  加载驱动：

depmod
modprobe mutex.ko

  使用 mutexApp 测试驱动：  

./mutexApp /dev/gpioled 1&  # 打开 LED 灯
./mutexApp /dev/gpioled 0&  # 关闭 LED 灯

  跟信号量的效果一样。卸载驱动：

rmmod mutex.ko

标签：led,14.2,LED,return,并发,实验,gpio,设备,gpioled
From： https://www.cnblogs.com/toutiegongzhu/p/17653236.html

相关文章

  • 并发问题和实现Callable接口
    并发1.初识并发问题//多个线程同时操作一个对象//买火车票//发现问题：多个线程操作同一个资源的情况下，线程不安全publicclassTestThread4implementsRunnable{  //票数  privateintticketNums=10;​  publicvoidrun(){    while(true){  ......
  • 《asyncio 系列》1. 什么是 asyncio？如何基于单线程实现并发？事件循环又是怎么工作的？
    https://www.cnblogs.com/traditional/p/17357782.html楔子许多应用程序，尤其在当今的Web应用程序领域，严重依赖IO操作。这些类型的操作包括从Intermet下载网页的内容、通过网络与一组微服务进行通信，或者针对MySOL、Postgres等数据库同时运行多个查询。Web请求或与微服......
  • pyhton解决高并发问题
    pyhton解决高并发问题#前端： 1.cdn加速，就是内容分发网络，简单来说就是把静态资源放到别的服务器上 2.精灵图：就是一个大的图片上面有多个我们需要的小图，用定位的方法，定位到不同的小图，满足我们的需求。这样一个请求拿到的图就可以用在多个位置。3.前端缓存：在返回的响应头里......
  • 14 Linux 并发与竞争
    一、并发与竞争  并发：多个执行单元同时、并行执行。  竞争：并发的执行单元同时访问共享资源(硬件资源和软件上的全局变量等)易导致竞态。 二、原子操作1.原子操作简介  原子操作：不能再进一步分割的操作，一般用于变量或位操作。  例如在C语言中对无符号整型变量......
  • c# .NET 高级编程 高并发必备技巧(二) - 分布式锁
    上一篇文章简单的介绍了单机的情况下如何进行加锁，防止高并发带来的问题。然而现实中，一般会高并发的应用，很少会单机部署。当用户量达到一定的程度，分布式、集群部署是必然的选择。在分布式部署的情况下，之前的单机锁还会有效吗？代码还是之前的代码：privatestaticobjectlck=......
  • 深入探索Java中的并发编程：CAS机制的原理与应用
    在当今多核处理器的时代，有效地利用多线程并发成为了现代后端开发的关键。在Java中，CAS（CompareandSwap）机制作为一种乐观锁技术，被广泛用于实现高性能的并发操作。本文将深入分析CAS机制的原理，介绍其在Java中的应用，以及在多线程环境下如何优化并发性能。CAS机制的原理CAS是一种用于实......
  • Go 并发编程 - Goroutine 基础 （一）
    基础概念进程与线程进程是一次程序在操作系统执行的过程，需要消耗一定的CPU、时间、内存、IO等。每个进程都拥有着独立的内存空间和系统资源。进程之间的内存是不共享的。通常需要使用IPC机制进行数据传输。进程是直接挂在操作系统上运行的，是操作系统分配硬件资源的最小单位。......
  • Go 并发编程 - 并发安全（二）
    什么是并发安全并发情况下，多个线程或协程会同时操作同一个资源，例如变量、数据结构、文件等。如果不保证并发安全，就可能导致数据竞争、脏读、脏写、死锁、活锁、饥饿等一系列并发问题，产生重大的安全隐患，比如12306抢到同一张火车票、多个用户抢到只剩一件库存的商品。而并发安全就......
  • Go 并发编程 - runtime 协程调度（三）
    GoRuntimeGoruntime可以形象的理解为Go程序运行时的环境，类似于JVM。不同于JVM的是，Go的runtime与业务程序直接打包在一块，是一个可执行文件，直接运行在操作系统上，效率很高。runtime包含了一些Go的一些非常核心的功能：协程调度、垃圾回收、内存分配等。本文将着重介绍......
  • 并发数据结构设计演练
    QuestDB是一个时间序列数据库，提供快速的摄取速度、InfluxDB线路协议和PGWire支持以及SQL查询语法。QuestDB主要是用Java编写的，我们学到了很多困难而有趣的教训。我们很高兴与您分享。研究数据结构并发数据结构设计很难。该博客提供了有关构建非常有利于读者的专用并发地图......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99