【Linux 并发与竞争实验】
【Linux 并发与竞争实验】
之前学习了四种常用的处理并发和竞争的机制：原子操作、自旋锁、信号量和互斥体。本章我们就通过四个实验来学习如何在驱动中使用这四种机制。
文章目录
- 【Linux 并发与竞争实验】
- 1.原子操作实验
- 1.1 实验程序编写
- 1.2 运行测试
- 2.自旋锁实验
- 2.1 实验程序编写
- 2.2 运行测试
- 3.信号量实验
- 3.1 实验程序编写
- 3.2 运行测试
- 4.互斥体实验
- 4.1 实验程序编写
- 4.2 运行测试
1.原子操作实验
本例程我们在《【Linux驱动开发】pinctrl 和 gpio 子系统实验》的 gpioled.c 文件基础上完成。在本节使用中我们使用原子操作来实现对 LED 这个设备的互斥访问，也就是一次只允许一个应用程序可以使用 LED 灯。
1.1 实验程序编写
1、修改设备树文件
因为本章实验是在《【Linux驱动开发】pinctrl 和 gpio 子系统实验》的基础上完成的，因此不需要对设备树做任何的修改。
链接地址：https://blog.csdn.net/v13111329954/article/details/146533517?spm=1001.2014.3001.5501
2、LED 驱动修改
本节实验在实验驱动文件 gpioled.c 的基础上修改而来。重命名为 atomic.c。
本节实验重点就是使用atomic 来实现一次只能允许一个应用访问 LED，所以我们只需要在 atomic.c 文件源码的基础上加上添加 atomic 相关代码即可，完成以后的 atomic.c 文件内容如下所示：
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编号 */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)) {atomic_inc(&gpioled.lock); /* 小于0的话就加1,使其原子变量等于0 */return -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;retvalue = copy_from_user(databuf, buf, cnt);if(retvalue < 0) {printk("kernel write failed!\r\n");return -EFAULT;}ledstat = databuf[0]; /* 获取状态值 */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;/* 关闭驱动文件的时候释放原子变量 */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;/* 初始化原子变量 */atomic_set(&gpioled.lock, 1); /* 原子变量初始值为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;} else {printk("gpioled node find!\r\n");}/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);if(gpioled.led_gpio < 0) {printk("can't get led-gpio");return -EINVAL;}printk("led-gpio num = %d\r\n", gpioled.led_gpio);/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭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);register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);} else { /* 没有定义设备号 */alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME); /* 申请设备号 */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);/* 4、创建类 */gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);if (IS_ERR(gpioled.class)) {return PTR_ERR(gpioled.class);}/* 5、创建设备 */gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);if (IS_ERR(gpioled.device)) {return PTR_ERR(gpioled.device);}return 0;
}/** @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);
}module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("jvmao");
第 33 行，原子变量 lock，用来实现一次只能允许一个应用访问 LED 灯，led_init 驱动入口函数会将 lock 的值设置为 1。
第 48~51 行，每次调用 open 函数打开驱动设备的时候先申请 lock，如果申请成功的话就表示LED灯还没有被其他的应用使用，如果申请失败就表示 LED灯正在被其他的应用程序使用。每次打开驱动设备的时候先使用 atomic_dec_and_test 函数将 lock 减 1，如果 atomic_dec_and_test函数返回值为真就表示 lock 当前值为 0，说明设备可以使用。如果 atomic_dec_and_test 函数返回值为假，就表示 lock 当前值为负数(lock 值默认是 1)，lock 值为负数的可能性只有一个，那就是其他设备正在使用 LED。其他设备正在使用 LED 灯，那么就只能退出了，在退出之前调用函数 atomic_inc 将 lock 加 1，因为此时 lock 的值被减成了负数，必须要对其加 1，将 lock 的值变为 0。
第 111 行，LED 灯使用完毕，应用程序调用 close 函数关闭的驱动文件，led_release 函数执行，调用 atomic_inc 释放 lcok，也就是将 lock 加 1。
第 134 行，初始化原子变量 lock，初始值设置为 1，这样每次就只允许一个应用使用 LED灯。
3、编写测试 APP
新建名为 atomicApp.c 的测试 APP，在里面输入如下所示内容：
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"
/***************************************************************
文件名 : atomicApp.c
描述 : 原子变量测试APP，测试原子变量能不能实现一次只允许一个应用程序使用LED。
使用方法 ：./atomicApp /dev/gpioled 0 关闭LED灯./atomicApp /dev/gpioled 1 打开LED灯
论坛 : www.openedv.com
日志 : 初版V1.0 2019/1/30 左忠凯创建
***************************************************************/#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];/* 打开beep驱动 */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;
}
atomicApp.c 中的内容就是在《【Linux驱动开发】pinctrl 和 gpio 子系统实验》的 ledAPP.c 的基础上修改而来的，重点是加入了第 60~64 行的模拟占用 25 秒 LED 的代码。测试 APP 在获取到 LED 灯驱动的使用权以后会使用 25S，在使用的这段时间如果有其他的应用也去获取 LED 灯使用权的话肯定会失败！
1.2 运行测试
1、编译驱动程序
编写 Makefile 文件，本章实验的 Makefile 文件和之前的基本一样，只是将 obj-m 变量的值改为 atomic.o，Makefile 内容如下所示：
KERNELDIR := /home/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)obj-m := atomic.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modulesclean:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第 4 行，设置 obj-m 变量的值为 atomic.o。
输入如下命令编译出驱动模块文件：
make -j32
编译成功以后就会生成一个名为“atomic.ko”的驱动模块文件。
2、编译测试 APP
输入如下命令编译测试 atomicApp.c 这个测试程序：
arm-linux-gnueabihf-gcc atomicApp.c -o atomicApp
编译成功以后就会生成 atomicApp 这个应用程序。
3、运行测试
将编译出来的 atomic.ko 和 atomicApp 这两个文件拷贝到 rootfs/lib/modules/4.1.15目录中，重启开发板，进入到目录 lib/modules/4.1.15 中，输入如下命令加载 atomic.ko 驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe atomic.ko //加载驱动
驱动加载成功以后就可以使用 atomicApp 软件来测试驱动是否工作正常，输入如下命令以后台运行模式打开 LED 灯，“&”表示在后台运行 atomicApp 这个软件：
./atomicApp /dev/gpioled 1& //打开 LED 灯
输入上述命令以后观察开发板上的红色 LED 灯是否点亮，然后每隔 5 秒都会输出一行“App running times ”，如图所示：
从图可以看出，atomicApp 运行正常，输出了“App running times:1”和“App running times:2”，这就是模拟 25S 占用，说明 atomicApp 这个软件正在使用 LED 灯。此时再输入如下命令关闭 LED 灯：
./atomicApp /dev/gpioled 0 //关闭 LED 灯
输入上述命令以后会发现如图所示输入信息：
从图可以看出，打开/dev/gpioled 失败！原因是在上上中运行的 atomicAPP软件正在占用/dev/gpioled，如果再次运行 atomicApp 软件去操作/dev/gpioled 肯定会失败。必须等待上上中的atomicApp运行结束，也就是25S结束以后其他软件才能去操作/dev/gpioled。
这个就是采用原子变量实现一次只能有一个应用程序访问 LED 灯。
如果要卸载驱动的话输入如下命令即可：
rmmod atomic.ko
2.自旋锁实验
上一节我们使用原子变量实现了一次只能有一个应用程序访问 LED 灯，本节我们使用自旋锁来实现此功能。在使用自旋锁之前，先回顾一下自旋锁的使用注意事项：
①、自旋锁保护的临界区要尽可能的短，因此在 open 函数中申请自旋锁，然后在 release 函数中释放自旋锁的方法就不可取。我们可以使用一个变量来表示设备的使用情况，如果设备被使用了那么变量就加一，设备被释放以后变量就减 1，我们只需要使用自旋锁保护这个变量即可。
②、考虑驱动的兼容性，合理的选择 API 函数。
综上所述，在本节例程中，我们通过定义一个变量 dev_stats 表示设备的使用情况，dev_stats为 0 的时候表示设备没有被使用，dev_stats 大于 0 的时候表示设备被使用。驱动 open 函数中先判断 dev_stats 是否为 0，也就是判断设备是否可用，如果为 0 的话就使用设备，并且将 dev_stats加 1，表示设备被使用了。使用完以后在 release 函数中将 dev_stats 减 1，表示设备没有被使用了。因此真正实现设备互斥访问的是变量 dev_stats，但是我们要使用自旋锁对 dev_stats 来做保护。
2.1 实验程序编写
1、修改设备树文件
因为本章实验是在《【Linux驱动开发】pinctrl 和 gpio 子系统实验》的基础上完成的，因此不需要对设备树做任何的修改。
2、LED 驱动修改
本节实验在第上一节实验驱动文件 atomic.c 的基础上修改而来。重命名为 spinlock.c。将原来使用 atomic 的地方换为 spinlock 即可，其他代码不需要修改，完成以后的 spinlock.c 文件内容如下所示(有省略)：
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编号 */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); /* 上锁 */if (gpioled.dev_stats) { /* 如果设备被使用了 */spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */return -EBUSY;}gpioled.dev_stats++; /* 如果设备没有打开，那么就标记已经打开了 */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;retvalue = copy_from_user(databuf, buf, cnt);if(retvalue < 0) {printk("kernel write failed!\r\n");return -EFAULT;}ledstat = databuf[0]; /* 获取状态值 */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_stats减1 */spin_lock_irqsave(&dev->lock, flags); /* 上锁 */if (dev->dev_stats) {dev->dev_stats--;}spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */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;/* 初始化自旋锁 */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;} else {printk("gpioled node find!\r\n");}/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);if(gpioled.led_gpio < 0) {printk("can't get led-gpio");return -EINVAL;}printk("led-gpio num = %d\r\n", gpioled.led_gpio);/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭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);register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);} else { /* 没有定义设备号 */alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME); /* 申请设备号 */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);/* 4、创建类 */gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);if (IS_ERR(gpioled.class)) {return PTR_ERR(gpioled.class);}/* 5、创建设备 */gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);if (IS_ERR(gpioled.device)) {return PTR_ERR(gpioled.device);}return 0;
}/** @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);
}module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("jvmao");
第 34 行，dev_stats 表示设备状态，如果为 0 的话表示设备还没有被使用，如果大于 0 的话就表示设备已经被使用了。
第 35 行，定义自旋锁变量 lock。
第 52~58 行，使用自旋锁实现对设备的互斥访问，第 52 行调用 spin_lock_irqsave 函数获取锁，为了考虑到驱动兼容性，这里并没有使用 spin_lock 函数来获取锁。第 53 行判断dev_stats 是否大于 0，如果是的话表示设备已经被使用了，那么就调用spin_unlock_irqrestore函数释放锁，并且返回-EBUSY。如果设备没有被使用的话就在第 57 行将 dev_stats 加 1，表示设备要被使用了，然后调用 spin_unlock_irqrestore 函数释放锁。自旋锁的工作就是保护dev_stats 变量，真正实现对设备互斥访问的是 dev_stats。
第 117~124 行，在 release 函数中将 dev_stats 减 1，表示设备被释放了，可以被其他的应用程序使用。将 dev_stats 减 1 的时候需要自旋锁对其进行保护。
第 146 行，在驱动入口函数 led_init 中调用 spin_lock_init 函数初始化自旋锁。
3、编写测试 APP
测试 APP 使用1.2小节中的 atomicApp.c 即可，将 7_atomic 中的 atomicApp.c 文件到本例程中，并将 atomicApp.c 重命名为 spinlockApp.c 即可。
2.2 运行测试
1、编译驱动程序
编写 Makefile 文件，将 obj-m 变量的值改为 spinlock.o，Makefile 内容如下所示：
KERNELDIR := /home/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)obj-m := spinlock.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modulesclean:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第 4 行，设置 obj-m 变量的值为 spinlock.o。
输入如下命令编译出驱动模块文件：
make -j32
编译成功以后就会生成一个名为“spinlock.ko”的驱动模块文件。
2、编译测试 APP
输入如下命令编译测试 spinlockApp.c 这个测试程序：
arm-linux-gnueabihf-gcc spinlockApp.c -o spinlockApp
编译成功以后就会生成 spinlockApp 这个应用程序。
3、运行测试
将编译出来的 spinlock.ko 和 spinlockApp 这两个文件拷贝到rootfs/lib/modules/4.1.15 目录中，重启开发板，进入到目录lib/modules/4.1.15 中，输入如下命令加载 spinlock.ko 驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe spinlock.ko //加载驱动
驱动加载成功以后就可以使用 spinlockApp 软件测试驱动是否工作正常，测试方法和上小节中一样，先输入如下命令让 spinlockAPP 软件模拟占用 25S 的 LED 灯：
./spinlockApp /dev/gpioled 1& //打开 LED 灯
紧接着再输入如下命令关闭 LED 灯：
./spinlockApp /dev/gpioled 0 //关闭 LED 灯
看一下能不能关闭 LED 灯，驱动正常工作的话并不会马上关闭 LED 灯，会提示你“file /dev/gpioled open failed!”，必须等待第一个 spinlockApp 软件运行完成(25S 计时结束)才可以再次操作 LED 灯。
如果要卸载驱动的话输入如下命令即可：
rmmod spinlock.ko
3.信号量实验
本节我们来使用信号量实现了一次只能有一个应用程序访问 LED 灯，信号量可以导致休眠，因此信号量保护的临界区没有运行时间限制，可以在驱动的 open 函数申请信号量，然后在release 函数中释放信号量。但是信号量不能用在中断中，本节实验我们不会在中断中使用信号量。
3.1 实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的，同样不需要对设备树做任何的修改。
2、LED 驱动修改
本节实验在第上一节实验驱动文件 spinlock.c 的基础上修改而来。重命名为 semaphore.c。将原来使用到自旋锁的地方换为信号量即可，其他的内容基本不变，完成以后的 semaphore.c 文件内容如下所示(有省略)：
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 <linux/semaphore.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编号 */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)) { /* 获取信号量,进入休眠状态的进程可以被信号打断 */return -ERESTARTSYS;}
#if 0down(&gpioled.sem); /* 不能被信号打断 */
#endifreturn 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;retvalue = copy_from_user(databuf, buf, cnt);if(retvalue < 0) {printk("kernel write failed!\r\n");return -EFAULT;}ledstat = databuf[0]; /* 获取状态值 */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;up(&dev->sem); /* 释放信号量，信号量值加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;/* 初始化信号量 */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;} else {printk("gpioled node find!\r\n");}/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);if(gpioled.led_gpio < 0) {printk("can't get led-gpio");return -EINVAL;}printk("led-gpio num = %d\r\n", gpioled.led_gpio);/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭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);register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);} else { /* 没有定义设备号 */alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME); /* 申请设备号 */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);/* 4、创建类 */gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);if (IS_ERR(gpioled.class)) {return PTR_ERR(gpioled.class);}/* 5、创建设备 */gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);if (IS_ERR(gpioled.device)) {return PTR_ERR(gpioled.device);}return 0;
}/** @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);
}module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("jvmao");
第 14 行，要使用信号量必须添加<linux/semaphore.h>头文件。
第 34 行，在设备结构体中添加一个信号量成员变量 sem。
第50~56行，在open函数中申请信号量，可以使用down函数，也可以使用down_interruptible函数。如果信号量值大于等于 1 就表示可用，那么应用程序就会开始使用 LED 灯。如果信号量值为 0 就表示应用程序不能使用 LED 灯，此时应用程序就会进入到休眠状态。等到信号量值大于 1 的时候应用程序就会唤醒，申请信号量，获取 LED 灯使用权。
第 114 行，在 release 函数中调用 up 函数释放信号量，这样其他因为没有得到信号量而进入休眠状态的应用程序就会唤醒，获取信号量。
第 138 行，在驱动入口函数中调用 sema_init 函数初始化信号量 sem 的值为 1，相当于 sem是个二值信号量。
总结一下，当信号量 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 灯。
3、编写测试 APP
测试 APP 用上一小节中的 atomicApp.c 即可，将 7_atomic 中的 atomicApp.c 文件到本例程中，并将 atomicApp.c 重命名为 semaApp.c 即可。
semaApp.c
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
/***************************************************************
文件名 : atomicApp.c
描述 : 原子变量测试APP，测试原子变量能不能实现一次只允许一个应用程序使用LED。
使用方法 ：./atomicApp /dev/gpioled 0 关闭LED灯./atomicApp /dev/gpioled 1 打开LED灯
论坛 : www.openedv.com
日志 : 初版V1.0 2019/1/30 左忠凯创建
***************************************************************/#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];/* 打开beep驱动 */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;
}
3.2 运行测试
1、编译驱动程序
编写 Makefile 文件，将 obj-m 变量的值改为 semaphore.o，Makefile 内容如下所示：
KERNELDIR := /home/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)obj-m := semaphore.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modulesclean:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第 4 行，设置 obj-m 变量的值为 semaphore.o。
输入如下命令编译出驱动模块文件：
make -j32
编译成功以后就会生成一个名为“semaphore.ko”的驱动模块文件。
2、编译测试 APP
输入如下命令编译测试 semaApp.c 这个测试程序：
arm-linux-gnueabihf-gcc semaApp.c -o semaApp
编译成功以后就会生成 semaApp 这个应用程序。
3、运行测试
将上一小节编译出来的 semaphore.ko 和 semaApp 这 两 个 文 件 拷 贝 到rootfs/lib/modules/4.1.15 目录中，重启开发板，进入到目录 lib/modules/4.1.15 中，输入如下命令加载 semaphore.ko 驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe semaphore.ko//加载驱动
驱动加载成功以后就可以使用 semaApp 软件测试驱动是否工作正常，先输入如下命令让 semaApp 软件模拟占用 25S 的 LED 灯：
./ semaApp /dev/gpioled 1& //打开 LED 灯
紧接着再输入如下命令关闭 LED 灯：
./ semaApp /dev/gpioled 0& //关闭 LED 灯
注意两个命令都是运行在后台，第一条命令先获取到信号量，因此可以操作 LED 灯，将LED 灯打开，并且占有 25S。第二条命令因为获取信号量失败而进入休眠状态，等待第一条命令运行完毕并释放信号量以后才拥有 LED 灯使用权，将 LED 灯关闭，运行结果如图所示：
如果要卸载驱动的话输入如下命令即可：
rmmod semaphore.ko
4.互斥体实验
前面我们使用原子操作、自旋锁和信号量实现了对 LED 灯的互斥访问，但是最适合互斥的就是互斥体 mutex 了。本节我们来学习一下如何使用 mutex 实现对 LED 灯的互斥访问。
4.1 实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的，同样不需要对设备树做任何的修改。
2、LED 驱动修改
本节实验在上一节实验驱动文件 semaphore.c 的基础上修改而来。重命名为 mutex.c。将原来使用到信号量的地方换为mutex即可，其他的内容基本不变，完成以后的 mutex.c 文件内容如下所示(有省略)：
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 <linux/semaphore.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编号 */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;}
#if 0mutex_lock(&gpioled.lock); /* 不能被信号打断 */
#endifreturn 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;retvalue = copy_from_user(databuf, buf, cnt);if(retvalue < 0) {printk("kernel write failed!\r\n");return -EFAULT;}ledstat = databuf[0]; /* 获取状态值 */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;/* 释放互斥锁 */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;/* 初始化互斥体 */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;} else {printk("gpioled node find!\r\n");}/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);if(gpioled.led_gpio < 0) {printk("can't get led-gpio");return -EINVAL;}printk("led-gpio num = %d\r\n", gpioled.led_gpio);/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭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);register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);} else { /* 没有定义设备号 */alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME); /* 申请设备号 */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);/* 4、创建类 */gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);if (IS_ERR(gpioled.class)) {return PTR_ERR(gpioled.class);}/* 5、创建设备 */gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);if (IS_ERR(gpioled.device)) {return PTR_ERR(gpioled.device);}return 0;
}/** @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);
}module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("jvmao");
第 43 行，定义互斥体 lock。
第 60~65 行，在 open 函数中调用 mutex_lock_interruptible 或者 mutex_lock 获取 mutex，成功的话就表示可以使用 LED 灯，失败的话就会进入休眠状态，和信号量一样。
第 124 行，在 release 函数中调用 mutex_unlock 函数释放 mutex，这样其他应用程序就可以获取 mutex 了。
第 148 行，在驱动入口函数中调用 mutex_init 初始化 mutex。
互斥体和二值信号量类似，只不过互斥体是专门用于互斥访问的。
3、编写测试 APP
测试 APP 使用上一小节中的 atomicApp.c 即可，将 7_atomic 中的 atomicApp.c 文件到本例程中，并将 atomicApp.c 重命名为 mutexApp.c 即可。
4.2 运行测试
1、编译驱动程序
编写 Makefile 文件，将 obj-m 变量的值改为 mutex.o，Makefile 内容如下所示：
KERNELDIR := /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)obj-m := mutex.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modulesclean:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第 4 行，设置 obj-m 变量的值为 mutex.o。
输入如下命令编译出驱动模块文件：
make -j32
编译成功以后就会生成一个名为“mutex.ko”的驱动模块文件。
2、编译测试 APP
输入如下命令编译测试 mutexApp.c 这个测试程序：
arm-linux-gnueabihf-gcc mutexApp.c -o mutexApp
编译成功以后就会生成 mutexApp 这个应用程序。
3、运行测试
将上一小节编译出来的 mutex.ko 和 mutexApp 这两个文件拷贝到 rootfs/lib/modules/4.1.15目录中，重启开发板，进入到目录 lib/modules/4.1.15 中，输入如下命令加载 mutex.ko 驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe mutex.ko //加载驱动
驱动加载成功以后就可以使用 mutexApp 软件测试驱动是否工作正常，测试方法和测试信号量的方法一样。
如果要卸载驱动的话输入如下命令即可：
rmmod mutex.ko
相关文章：
【Linux 并发与竞争实验】
【Linux 并发与竞争实验】 之前学习了四种常用的处理并发和竞争的机制：原子操作、自旋锁、信号量和互斥体。本章我们就通过四个实验来学习如何在驱动中使用这四种机制。 文章目录 【Linux 并发与竞争实验】1.原子操作实验1.1 实验程序编写1.2 运行测试 2.自旋锁实验…...
数据一致性策略之延迟双删-实现
延迟双删 查询数据之前优先去查Redis的缓存数据，减少数据库压力； 如果没有缓存会去查数据库，通过查询数据库后缓存热点Key Cache-Aside策略 高并发场景时，严重生产bug：数据不一致 业务场景： 事务1&#x…...
在PyTorch中，使用不同模型的参数进行模型预热
在PyTorch中，使用不同模型的参数进行模型预热（Warmstarting）是一种常见的迁移学习和加速训练的策略。以下是结合多个参考资料总结的实现方法和注意事项： 1. 核心机制：load_state_dict()与strict参数 • 部分参数加载&…...
【AI论文】InternVL3：探索开源多模态模型的高级训练和测试时间配方
摘要：我们推出了InternVL3，这是InternVL系列的一项重大进步，具有本地多模态预训练范式。 InternVL3不是将纯文本的大型语言模型（LLM）改编成支持视觉输入的多模态大型语言模型（MLLM），…...
基于Linux的ffmpeg python的关键帧抽取
1.FFmpeg的环境配置 首先强调，ffmpeg-python包与ffmpeg包不一样。 1) 创建一个虚拟环境env conda create -n yourenv python3.x conda activate yourenv2) ffmpeg-python包的安装 pip install ffmpeg-python3) 安装系统级别的 FFmpeg 工具 虽然安装了 ffmpeg-p…...
CNN：卷积到底做了什么？
卷积神经网络（Convolutional Neural Network, CNN） 是一种深度学习模型，专门用于处理具有网格结构的数据（如图像、视频等）。它在计算机视觉领域表现卓越，广泛应用于图像分类、目标检测、图像分割等任务。CN…...
C++ IO流
文章目录 C IO流流是什么C标准IO流C文件IO流c字符串流 C IO流 流是什么 在 C 中，“流（Stream）” 是一种 抽象的数据传输机制，它通过统一的接口实现了程序与各种输入/输出设备（如键盘、屏幕、文件、内存等）…...
解决splice改变原数组的BUG（拷贝数据）
项目场景： 项目中难免遇到需要删除改变数组的方法，去重，删除不要的数据等 问题描述： 但是splice方法会删除掉数据改变原数组，返回的是改变之后的数组，即使你是赋值的还是会影响到原数组的数据 GoodsInfo…...
)
ARINC818协议(二)
ARINC818对图像数据进行帧分割 1.FC协议定了5层模型结构：FC-4;FC-3;FC-2;FC-1;FC-0; 2.ARINC818协议位于FC-4层； 3.ARINC818协议在FC-4层使用FHCP帧头控制协议进行实现数据传递； 4.协议中有容器，容器头，object0~object…...
【Netty篇】Future Promise 详解
目录 一、 Netty Future 与 Promise —— 异步世界的“信使”与“传话筒”🚀1、 理解 Netty Future2、 理解 Netty Promise 二、 代码案例解读💻例1：同步处理任务成功👍例2：异步处理任务成功📲例3ÿ…...
【LaTeX】Misplaced alignment tab character . ^^I
目录 公式中出现Misplaced alignment tab character &. ^^I& 解决1：采用&& 解决2： 公式中出现Misplaced alignment tab character &. ^^I& \begin{equation}J_r & \dfrac{i\hbar}{2m}\left[\psi_2 \dfrac{\partial \psi^…...
数据中台（大数据平台）之元数据管理
👉元数据管理是数据管理的基础，数据中台产品要能够提供各类元数据采集的适配器，自动化采集技术元数据，并在技术元数据的基础上补充管理属性和业务属性，为后续的数据资源目录、数据安全管控、报表开发提供统一的口径。并…...
基于RRT的优化器：一种基于快速探索随机树算法的新型元启发式算法
受机器人路径规划中常用的快速探索随机树（RRT）算法的搜索机制的启发，我们提出了一种新颖的元启发式算法，称为基于RRT的优化器（RRTO）。这是首次将RRT算法的概念与元启发式算法相结合。RRTO的关键创新是其三种…...
设计模式每日硬核训练 Day 13：桥接模式（Bridge Pattern）完整讲解与实战应用
🔄 回顾 Day 12：装饰器模式小结 在 Day 12 中，我们学习了装饰器模式（Decorator Pattern）： 强调在不改变原类结构的前提下，动态为对象增强功能。通过“包装对象”实现运行时组合，支…...
【开发语言】悬空指针问题
悬空指针（Dangling Pointer）是编程中常见的内存管理问题，尤其在C/C这类手动管理内存的语言中。以下是详细解释： 什么是悬空指针？ 悬空指针是指向已经被释放（或失效）内存的指针。这段内存可能已…...
深入剖析 WiFi 定位解析功能：原理、技术优势与应用场景
WiFi 定位解析功能的原理 信号强度与距离的关系 WiFi 定位的核心原理基于无线信号传播过程中的一个基本特性：信号强度与信号发射源（即 WiFi 接入点，Access Point，简称 AP）和接收设备之间距离的关联。一般来说&am…...
从标准九九表打印解读单行表达式的书写修炼（Python）
解读单行表达式书写，了解修习单行捷径。 笔记模板由python脚本于2025-04-16 23:24:17创建，本篇笔记适合喜欢单行喜好python的coder翻阅。 【学习的细节是欢悦的历程】 博客的核心价值：在于输出思考与经验，而不仅仅是知识的简单复述…...
HTML5好看的水果蔬菜在线商城网站源码系列模板4
文章目录 1.设计来源1.1 主界面1.2 关于我们1.3 商品信息1.4 新闻资讯1.5 联系我们1.5 登录注册 2.效果和源码2.1 动态效果2.2 源代码 源码下载 作者：xcLeigh 文章地址：https://blog.csdn.net/weixin_43151418/article/details/147264262 HTML5好看的水果…...
Arkts应用全局UI状态存储和持久化V2（AppStorageV2、PersistenceV2和@Type）
目录 应用全局UI状态存储和持久化V2版本 AppStorageV2 connect remove keys 示例 使用限制 PersistenceV2 connect remove keys save notifyOnError 示例 使用限制 Type 使用限制 应用全局UI状态存储和持久化V2版本 以下实例AppStorageV2、PersistenceV2和装饰…...
【QT】常用控件 【多元素类 | 容器类 | 布局类】
🌈 个人主页：Zfox_ 🔥 系列专栏：Qt 目录 一：🔥 QT 常用控件【多元素类】 🦋 List Widget -- 列表🦋 Table Widget -- 表格🦋 Tree Widget -- 树形 二：&#x…...
uniapp实现图文聊天功能
Uniapp 实现图文聊天功能 下面我将介绍如何在 Uniapp 中实现一个基本的图文聊天功能，包括消息发送、接收和展示。 一、准备工作 创建 Uniapp 项目准备后端接口（可以使用云开发、自己的服务器或第三方服务） 二、实现步骤 1. 页面结构 &l…...
【场景应用9】多语言预训练语音模型进行自动语音识别
一、理论介绍 “多语言预训练语音模型进行自动语音识别”这个模块是近年来语音识别（ASR, Automatic Speech Recognition）领域非常重要的发展方向。下面我来为你系统地讲解这个模块的基础理论与算法流程，尤其聚焦在如 wav2vec 2.0 multilingual、XLSR（cross-lingual speech…...
华为HCIE-openEuler认证：能否成为国产操作系统领域的技术稀缺人才？
HCIE-openEuler是华为面向开源操作系统领域的高级专家认证，聚焦openEuler系统的深度运维、性能调优与生态集成。作为华为鲲鹏计算生态的核心技术栈，该认证要求持证者具备从底层内核优化到上层云原生适配的全栈能力。以下从技术能力、实验设计、行业适配三…...
Uniapp：列表选择提示框
目录 一、出现场景二、效果展示三、具体使用 一、出现场景 在项目的开发过程中，有这样一种场景，就是点击按钮走后续的逻辑之前还需要选择前提条件，就一个条件的情况下如果使用弹出框就显示比较多余，列表选择提示框刚好能够满足我…...
uni-app 开发安卓 您的应用在运行时，向用户索取（定位、相机、存储）等权限，未同步告知权限申请的使用目的，不符合相关法律法规要求
您的应用在运行时，向用户索取（定位、相机、存储）等权限，未同步告知权限申请的使用目的，不符合相关法律法规要求。 测试步骤：1、 工作台 -打卡，申请定位权限；2、工作台-设置-编辑资料-更换头像，申请相机、存 储权限。 修改建议：APP在申请敏感权限时，应同步说明权限申…...
李宏毅NLP-4-语音识别part3-CTC
Connectionist Temporal Classification｜CTC 基于连接主义时间分类（CTC）的语音识别架构，具体描述如下： 输入层：底部的 x 1 , x 2 , x 3 , x 4 x^1, x^2, x^3, x^4 x1,x2,x3,x4代表输入的语音信号分帧数据…...
基于.NET后端实现图片搜索图片库 核心是计算上传图片与库中图片的特征向量相似度并排序展示结果
基于.NET 后端实现图片搜索图片库的方案，核心是计算上传图片与库中图片的特征向量相似度并排序展示结果。 整体思路 图像特征提取：使用深度学习模型（如 ResNet）提取图片的特征向量。特征向量存储：将图片的特征向量存…...
数据中台（大数据平台）之数据仓库建设
数据中台作为企业数据管理的核心枢纽，应支持并促进企业级数据仓库的建设，确保数据的有效整合、治理和高效应用。在建设数据仓库的过程中，设计和规划显得尤为重要，需要深入理解业务需求，制定合理的技术架构，…...
：在商品对象创建系统中的应用)
设计模式之工厂模式(factory pattern)：在商品对象创建系统中的应用
目录 一、设计思路 1. 简单工厂模式 2. 工厂方法模式 3. 抽象工厂模式 二、UML类图（PlantUML格式） 1.简单工厂模式 2.工厂方法模式 3.抽象工厂模式 三、实现过程与结果 1. 简单工厂模式 2. 工厂方法模式 3. 抽象工厂模式 四、总结 在面向对…...
在ubuntu20.04+系统部署VUE及Django项目的过程记录——以腾讯云为例
目录 1. 需求2. 项目准备3. VUE CLI项目部署3.1 部署前的准备3.1.1 后端通信路由修改3.1.2 导航修改 3.2 构建项目3.3 配置nginx代理 4. 后端配置4.1 其他依赖项4.2 单次执行测试4.3 创建Systemd 服务文件4.4 配置 Nginx 作为反向代理 5. 其他注意事项 1. 需求 近期做一些简单…...
解决前端vue项目在linux上，npm install，node-sass 安装失败的问题
Unable to save binary /var/lib/jenkins/workspace/xxx/node_modules/node-sass/vendor/linux-x64-72 : Error: EACCES: permission denied, mkdir ‘/var/lib/jenkins/workspace/x/node_modules/node-sass/vendor’ 这个是node-sass安装失败导致的。 #将npm的默认仓库更改为…...
用HLS实现循环展开以及存储模块)
FPGA_YOLO(四)用HLS实现循环展开以及存储模块
Vivado HLS（High-Level Synthesis，高层次综合）是赛灵思（Xilinx）在其 Vivado 设计套件 中提供的一款工具，用于将 高级编程语言（如 C、C、SystemC） 直接转换为 硬件描述语言࿰…...
用户组与用户
用户组管理： 创建用户组： groupadd 用户组名 删除用户组： groupdel 用户组名 用户管理： 创建用户 useradd [-g -d] 用户名 -g：指定用户的组 -d：指定用户的home路径，如果不加上&…...
npm install 报错常见的解决方法
npm install 报错的情况有很多种，每种错误的具体解决方案也有所不同。这里我将汇总一些常见的npm install报错及其解决办法： 1. 下载速度慢/网络问题 解决办法：更换npm包的镜像源至国内镜像，如淘宝npm镜像：npm confi…...
暂存一下等会写
#include<easyx.h> IMAGE SNOW 图形变量 struct MOVE生存结构体 {int x0;int y0; bool livefalse;}; initgraph(800, 800);初始化图形界面 MOVE snowflake[5000];目标数量 loadimage(&SNOW, "snow.png");加载图片 BeginBatchDraw(); 开始批量绘图。…...
C语言 —— 指尖跃迁 刻印永恒 - 文件操作
目录 1. 什么是文件 1.1 程序文件 1.2 数据文件 1.3 文件名 2. 二进制文件和文本文件 3. 文件的打开与关闭 3.1 流和标准流 3.2 文件指针 3.3 文件的打开与关闭 fopen fclose 4. 文件的顺序读写 4.1 fgetc和fputc fgetc fputc 4.2 fgets和fputs fgets fputs…...
第二章 DQL查询语句
第一章：基础查询 一、SELECT 语句 作用 SELECT 语句用于从数据库中选取数据。 结果被存储在一个结果表中，称为结果集。 语法 SELECT column1, column2, … FROM table_name; 与 SELECT * FROM table_name; 参数说明： column1, column2, …...
系统与网络安全------弹性交换网络（1）
资料整理于网络资料、书本资料、AI，仅供个人学习参考。 Trunk原理与配置 Trunk原理概述 Trunk（虚拟局域网中继技术）是指能让连接在不同交换机上的相同VLAN中的主机互通。 VLAN内通信 实现跨交换的同VLAN通信，通过Trunk链路&am…...
有哪些哲学流派适合创业二
好的，让我们更深入地探讨如何将哲学与数学深度融合，构建一套可落地的创业操作系统。以下从认知框架、决策引擎、执行算法三个维度展开，包含具体工具和黑箱拆解： 一、认知框架：用哲学重构商业本质 1. 本体…...
Python（18）Python中JSON的妙用：详解序列化与反序列化原理及实战案例
目录 一、背景：为什么Python需要JSON？二、核心技术解析：序列化与反序列化2.1 核心概念2.2 类型映射对照表 三、Python操作JSON的四大核心方法3.1 基础方法库3.2 方法详解1. json.dumps()2. json.loads()3. json.dump()4. json.load() 四、实战…...
Nautilus 正式发布：为 Sui 带来可验证的链下隐私计算
作为 Sui 安全工具包中的强大新成员，Nautilus 现已上线 Sui 测试网。它专为 Web3 开发者打造，支持保密且可验证的链下计算。Nautilus 应用运行于开发者自主管理的可信执行环境（Trusted Execution Environment，TEE）中&a…...
投资理财_从0到1：如何用1000元开启你的二级市场投资之旅？
投资理财_从0到1：如何用1000元开启你的二级市场投资之旅？ 一、前言：投资不是赌博，而是科学与艺术的结合1.1 为什么学习二级市场投资？1.2 本篇博客的目标 二、投资的基本概念：先搞清楚“玩的是什么”2.1 二级…...
有没有适合企业用的局域网即时通讯聊天工具？
随着信息安全问题的日益凸显，用户对于即时通讯工具的安全性与隐私保护提出了更高的要求。 强大的即时通讯能力 BeeWorks提供了专业的IM即时通讯能力，支持多种消息类型，包括文字、语音、图片和文件等，满足不同场景下的沟通需求。…...
Web3技术如何提升用户数据保护
在这个信息爆炸的时代，用户数据保护已成为全球关注的焦点。Web3 技术，作为下一代互联网的代表，以其去中心化、安全性和用户主权等特点，为用户数据保护提供了新的解决方案。本文将探讨 Web3 技术如何提升用户数据保护。 去中心化存…...
CANoe自动化测试用例log保存（专栏：车载网络诊断测试攻略从零开始搭建一个UDS诊断自动化测试CANoe工程）
文章目录 前言实现思路以及对应的CAPL代码1.获取cfg工程路径2.获取系统时间3.html报告路径4.log路径5.保存报告6.用例示例在汽车电子系统的开发与测试中，CANoe作为主流的仿真测试工具，其自动化测试用例生成的Log是问题追溯、合规审计和数据分析的核心依据。然而，许多团队因日…...
 的工作原理和优势)
理解 results = model(source, stream=True) 的工作原理和优势
1. 核心概念解析 (1) streamTrue 的作用 生成器模式：当处理视频或图像序列时，streamTrue 会将结果包装成一个 生成器（Generator），逐帧生成 Results 对象，而不是一次性返回所有结果。内存优化：…...
# 手写数字识别：使用PyTorch构建MNIST分类器
手写数字识别：使用PyTorch构建MNIST分类器 在这篇文章中，我将引导你通过使用PyTorch框架构建一个简单的神经网络模型，用于识别MNIST数据集中的手写数字。MNIST数据集是一个经典的机器学习数据集，包含了60,000张训练图像和10,000张…...
ios app的ipa文件提交最简单的方法
ipa文件是ios的app打包后生成的二级制文件，在上架app store connect或做testflight测试的时候，它提示我们需要使用xcode、transporter或xcode命令行等方式来上传。 而xcode、transporter或xcode命令行的安装都需要使用mac电脑，假如没有mac电…...
与/或形演绎推理——基于王永庆著《人工智能原理与方法》的深度解析
前文，我们已经写了两种演绎推理：自然演绎推理和归结演绎推理。 自然演绎推理：自然演绎推理——基于王永庆著《人工智能原理与方法》的深度解析-CSDN博客 归结演绎推理：归结演绎推理——基于王永庆著《人工智能原理与方法》的深度…...
【Qt】Qt 按钮控件详解，PushButton，RadioButton，CheckBox，ToolButton
🍑个人主页：Jupiter. 🚀 所属专栏：QT 欢迎大家点赞收藏评论😊 目录 📚按钮类控件🍑Push Button 🥥Radio Buttion🍃click, press, release, toggled 的区别🍁…...