当前位置: 首页 > news >正文

Linux驱动实现IO模型

在Linux系统分为内核态和用户态,CPU会在这两个状态之间进行切换。当进行IO操作时,应用程序会使用系统调用进入内核态,内核操作系统会准备好数据,把IO设备的数据加载到内核缓冲区。

然后内核操作系统会把内核缓冲区的数据从内核空间拷贝到用户空间。但是进行IO操作时,CPU和内存的速度远远高于外设的速度,所以需要我们使用IO模型编程解决。

IO模型的种类:

  • 阻塞IO
  • 非阻塞IO
  • IO多路复用
  • 信号驱动IO
  • 异步IO

阻塞IO

当进程以阻塞的方式打开设备文件时(默认方式),如果资源不可用,那么进程阻塞,也就是进程休眠。既然有休眠,就有对应的唤醒操作,否则进程将会一直休眠下去。驱动程序应该在资源可用时负责唤醒操作。相比于非阻塞IO,其最大的优点就是,资源不可用时,不占用CPU的时间,而非阻塞IO必须要定期尝试,看看资源是否可以获得,这对于键盘鼠标这类设备来说,其效率非常低。但是阻塞IO也有一个明显的缺点,那就是进程在休眠期间再也不能做其他事情。

通过上面的描述,发现要实现阻塞操作最重要的数据结构就是等待队列。不了解等待队列的请参考(等待队列)。

下面通过一个简单的驱动程序来实现阻塞IO模型。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/ioctl.h>
#include <linux/miscdevice.h>
#include <linux/wait.h>
#include <linux/sched.h>struct devices {char buffer[32];int flag;
};struct devices qw_dev;DECLARE_WAIT_QUEUE_HEAD(wqh);int test_open(struct inode *inode, struct file *filp)
{filp->private_data = &qw_dev;printk("dev open!\n");return 0;
}ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;wait_event_interruptible(wqh, dev->flag);if(copy_to_user(buf, dev->buffer, size)!=0) {printk("copy to user error\n");return -EFAULT;}return size;
}ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;if(copy_from_user(dev->buffer, buf, size)) {printk("copy from user error\n");return -EFAULT;}dev->flag = 1;wake_up_interruptible(&wqh);printk("WRITE: %s\n", dev->buffer);return size;}int test_release(struct inode *inode, struct file *filp)
{printk("dev close!\n");return 0;
}//声明操作函数集合
struct file_operations wq_fops = {.owner = THIS_MODULE,.open = test_open,.read = test_read,.write = test_write,.release = test_release,
};//分配初始化miscdevice
struct miscdevice misc_dev = {.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号.name = "qw",//设备文件名.fops = &wq_fops,//操作函数集合
};//加载函数
int test_init(void)
{int ret;//注册miscdeviceret = misc_register(&misc_dev);if (ret < 0) {misc_deregister(&misc_dev);return -1;}qw_dev.flag = 0;return 0;}//卸载函数
void test_exit(void)
{//注销miscdevice	misc_deregister(&misc_dev);
}//声明为模块的入口和出口
module_init(test_init);
module_exit(test_exit);MODULE_LICENSE("GPL");//GPL模块许可证
MODULE_AUTHOR("xin");//作者
MODULE_VERSION("2.0");//版本
MODULE_DESCRIPTION("WQ driver!");//描述信息

向驱动写数据的应用程序。 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>int main(int argc, char *argv[])
{int fd;char buf2[32] = "hello world";fd = open("/dev/qw", O_RDWR);if (fd < 0) {perror("open error");return fd;}write(fd, buf2, strlen(buf2));close(fd);return 0;
}

向驱动读数据的应用程序。 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>int main(int argc, char *argv[])
{int fd;char buf1[32] = {0};fd = open("/dev/qw", O_RDWR);if (fd < 0) {perror("open error");return fd;}read(fd, buf1, 32);printf("READ:%s\n",buf1);close(fd);return 0;
}

将驱动模块加载到内核中后,先运行读程序,发现程序会阻塞。然后另开一个终端运行写程序,读程序才会打印写程序的数据。

非阻塞IO

设备不一定随时都能给用户提供服务,这就有了资源可用和不可用两种状态。如果应用程序以非阻塞的方法打开设备文件,当资源不可用时,驱动就应该立即返回,并用一个错误码EAGAIN来通知应用程序此时资源不可用,应用程序应该稍后再尝试。

下面通过一个简单的驱动程序来实现阻塞IO模型。在阻塞IO模型上进行修改,当应用程序打开设备文件时,以非阻塞方式打开 。

fd = open("/dev/qw", O_RDWR | O_NONBLOCK);

驱动程序读函数中判断设备是否以非阻塞方式打开,并且资源是否准备好。struct file 结构体中的f_flags成员存储打开设备文件的标志。

if (filp->f_flags & O_NONBLOCK) {if (dev->flag != 1) {return -EAGAIN;}
}

驱动程序 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/ioctl.h>
#include <linux/miscdevice.h>
#include <linux/wait.h>
#include <linux/sched.h>struct devices {char buffer[32];int flag;
};struct devices qw_dev;DECLARE_WAIT_QUEUE_HEAD(wqh);int test_open(struct inode *inode, struct file *filp)
{filp->private_data = &qw_dev;printk("dev open!\n");return 0;
}ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;if (filp->f_flags & O_NONBLOCK) {if (dev->flag != 1) {return -EAGAIN;}}wait_event_interruptible(wqh, dev->flag);if(copy_to_user(buf, dev->buffer, size)!=0) {printk("copy to user error\n");return -EFAULT;}return size;
}ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;if(copy_from_user(dev->buffer, buf, size)) {printk("copy from user error\n");return -EFAULT;}dev->flag = 1;wake_up_interruptible(&wqh);printk("WRITE: %s\n", dev->buffer);return size;}int test_release(struct inode *inode, struct file *filp)
{printk("dev close!\n");return 0;
}//声明操作函数集合
struct file_operations wq_fops = {.owner = THIS_MODULE,.open = test_open,.read = test_read,.write = test_write,.release = test_release,
};//分配初始化miscdevice
struct miscdevice misc_dev = {.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号.name = "qw",//设备文件名.fops = &wq_fops,//操作函数集合
};//加载函数
int test_init(void)
{int ret;//注册miscdeviceret = misc_register(&misc_dev);if (ret < 0) {misc_deregister(&misc_dev);return -1;}qw_dev.flag = 0;return 0;}//卸载函数
void test_exit(void)
{//注销miscdevice	misc_deregister(&misc_dev);
}//声明为模块的入口和出口
module_init(test_init);
module_exit(test_exit);MODULE_LICENSE("GPL");//GPL模块许可证
MODULE_AUTHOR("xin");//作者
MODULE_VERSION("2.0");//版本
MODULE_DESCRIPTION("WQ driver!");//描述信息

读应用程序如下所示,写程序前面的一样就不展示出来。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>int main(int argc, char *argv[])
{int fd;char buf1[32] = {0};fd = open("/dev/qw", O_RDWR | O_NONBLOCK);if (fd < 0) {perror("open error");return fd;}while(1) {read(fd, buf1, 32);printf("READ:%s\n",buf1);sleep(1);}close(fd);return 0;
}

将驱动模块加载到内核中后,先运行读程序,发现程序不会阻塞,但是没有数据。然后另开一个终端运行写程序,读程序才会打印出写程序的数据。

IO多路复用

阻塞IO优点是在设备资源不可用时,进程主动放弃CPU,但是进程阻塞后不能做其他操作。非阻塞IO优点是资源不可用时不会阻塞,但是会不停地轮询,系统效率降低。当一个进程要同时对多个设备进程操作时以上两种方法显得非常不方便。这就需要使用到IO复用模型。

它允许一个进程可以同时监视多个文件描述符,并且可以在其中任何一个文件描述符上等待数据可读或可写,从而实现并发IO操作。在应用程序中Linux提供了三种API函数:poll,select和epoll。在驱动程序中只需要实现poll函数。

poll和select基本上是一样 ,都可以监听多个文件描述符,通过轮询多个文件描述符来获得已经准备好的文件描述符。epoll是将主动轮询变成了被动通知,当事件发生时,被动的接受通知。

接下来以poll为例进行说明,应用程序中poll系统调用的原型及相关的数据类型如下。

int poll (struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd {

        int fd;

        short events;

        short revents;

};

POLLIN There is data to read.

POLLOUT Writing now will not block.

POLLRDNORM Equivalent to POLLIN.

POLLWRNORM Equivalent to POLLOUT.

poll的第一个参数是要监听的文件描述符集合,类型为指向struct pollfd的指针,struct pollfd有3个成员,fd是要监听文件描述符,events是监听的事件,revents是返回的事件。常见的事件有POLLIN、POLLOUT,分别表示设备可以无阻塞地读、写。POLLRDNORM和POLLWRNORM是在_XOPEN_SOURCE宏被定义时所引入的事件,POLLRDNORM通常和POLLIN等价,POLLWRNORM通常和POLLOUT等价。

poll函数的第二个参数是要监听的文件描述符的个数,第三个参数的毫秒的超时值,负数表示一直监听,直到被监听的文件描述符集合中的任意一个设备发生了事件才会返回。函数返回值为-1表示失败,成功返回revents不为0的文件描述符个数。

读应用程序如下所示,写程序前面的一样就不展示出来。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <poll.h>int main(int argc, char *argv[])
{int fd;int ret;char buf1[32] = {0};struct pollfd fds[1];fd = open("/dev/qw", O_RDWR | O_NONBLOCK);if (fd < 0) {perror("open error");return fd;}fds[0].fd = fd;fds[0].events = POLLIN;while(1) {ret = poll(fds, 1, 5000);if (!ret) {printf("timeout\n");} else if (fds[0].revents == POLLIN) {read(fd, buf1, 32);printf("READ:%s\n",buf1);sleep(1);}}close(fd);return 0;
}

驱动中poll函数需要完成两点:1. 对可能引起设备文件状态变化的等待队列调用poll_wait函数,将对应的等待队列头添加到poll_table。2. 返回表示是否能对设备进行无阻塞读写访问的掩码。

static __poll_t test_poll(struct file *filp, struct poll_table_struct *p)
{struct devices *dev = (struct devices *)filp->private_data;__poll_t mask = 0;poll_wait(filp, &wqh, p);if (dev->flag = 1) {mask |= POLLIN;}return mask;
}

注意:poll_wait函数不会阻塞。

驱动程序

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/ioctl.h>
#include <linux/miscdevice.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>struct devices {char buffer[32];int flag;
};struct devices qw_dev;DECLARE_WAIT_QUEUE_HEAD(wqh);int test_open(struct inode *inode, struct file *filp)
{filp->private_data = &qw_dev;printk("dev open!\n");return 0;
}ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;if (filp->f_flags & O_NONBLOCK) {if (dev->flag != 1) {return -EAGAIN;}}wait_event_interruptible(wqh, dev->flag);if(copy_to_user(buf, dev->buffer, size)!=0) {printk("copy to user error\n");return -EFAULT;}return size;
}ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;if(copy_from_user(dev->buffer, buf, size)) {printk("copy from user error\n");return -EFAULT;}dev->flag = 1;wake_up_interruptible(&wqh);printk("WRITE: %s\n", dev->buffer);return size;}static __poll_t test_poll(struct file *filp, struct poll_table_struct *p)
{struct devices *dev = (struct devices *)filp->private_data;__poll_t mask = 0;poll_wait(filp, &wqh, p);if (dev->flag == 1) {mask |= POLLIN;}return mask;
}int test_release(struct inode *inode, struct file *filp)
{printk("dev close!\n");return 0;
}//声明操作函数集合
struct file_operations wq_fops = {.owner = THIS_MODULE,.open = test_open,.read = test_read,.write = test_write,.poll = test_poll,.release = test_release,
};//分配初始化miscdevice
struct miscdevice misc_dev = {.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号.name = "qw",//设备文件名.fops = &wq_fops,//操作函数集合
};//加载函数
int test_init(void)
{int ret;//注册miscdeviceret = misc_register(&misc_dev);if (ret < 0) {misc_deregister(&misc_dev);return -1;}qw_dev.flag = 0;return 0;}//卸载函数
void test_exit(void)
{//注销miscdevice	misc_deregister(&misc_dev);
}//声明为模块的入口和出口
module_init(test_init);
module_exit(test_exit);MODULE_LICENSE("GPL");//GPL模块许可证
MODULE_AUTHOR("xin");//作者
MODULE_VERSION("2.0");//版本
MODULE_DESCRIPTION("WQ driver!");//描述信息

将驱动模块加载到内核中后,先运行读程序,发现程序不会阻塞,但是没有数据且每5s打印超时。然后另开一个终端运行写程序,读程序才会打印出写程序的数据。

信号驱动IO

在信号驱动IO中,进程使用系统调用 sigaction() 来注册一个信号处理函数,该函数会在IO事件就绪时被内核调用。当进程调用 sigaction() 注册一个信号处理函数时,它需要指定一个描述符和一个事件,内核在检测到该描述符上发生指定事件时,会向进程发送指定信号。进程可以通过捕获该信号并执行信号处理函数。

与其他IO多路复用技术相比,信号驱动IO也避免了轮询机制的开销,从而减少了 CPU 的占用。但是,信号驱动IO也存在一些缺点。首先,它对信号的处理需要一定的时间,因此它不适合高速IO操作。其次,由于信号是不可靠的,因此在使用信号驱动IO时需要考虑到信号可能会丢失的情况。

在应用程序使用信号驱动IO,需要完成以下几步:1. 注册信号处理函数,应用程序使用 sigaction()来注册一个信号处理函数。2. 设置能接受这个信号的进程。 3. 开启信号驱动IO,通常是使用fcntl函数的F_SETFL命令打开FASYNC标志。

fcntl系统调用可以用来对已打开的文件描述符进行各种控制操作以改变已打开文件的的各种属性。

函数原型:

#include<unistd.h>
#include<fcntl.h>
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd ,struct flock* lock);

fcntl函数功能依据cmd的值的不同而不同。参数对应功能如下:

读应用程序如下所示,写程序前面的一样就不展示出来。 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>int fd;
char buf1[32] = {0};static void test_func(int signal)
{read(fd, buf1, 32);printf("READ:%s\n",buf1);
}int main(int argc, char *argv[])
{int flags;fd = open("/dev/qw", O_RDWR | O_NONBLOCK);if (fd < 0) {perror("open error");return fd;}signal(SIGIO, test_func);            //注册信号处理函数test_funcfcntl(fd, F_SETOWN, getpid());       //设置当前进程接收SIGIO信号flags = fcntl(fd, F_GETFD);          //获得文件描述符标志fcntl(fd, F_SETFL, flags | FASYNC);  //设置文件状态标志,在原来文件描述符标志上开启FASYNC标志while(1);close(fd);return 0;
}

当应用程序开启信号驱动IO时,会触发驱动程序中的fasync函数,而fasync函数会调用fasync_helper函数去初始化fasync_struct结构体。 当数据到达时调用kill_fasync函数用来通知应用程序,然后应用程序执行信号处理函数,它的参数是被传递的信号(常常是 SIGIO)和 band 。band:可读时设置成POLLIN,可写时设置成POLLOUT。 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/ioctl.h>
#include <linux/miscdevice.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>struct devices {char buffer[32];int flag;struct fasync_struct *fasync;
};struct devices qw_dev;DECLARE_WAIT_QUEUE_HEAD(wqh);int test_open(struct inode *inode, struct file *filp)
{filp->private_data = &qw_dev;printk("dev open!\n");return 0;
}ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;if (filp->f_flags & O_NONBLOCK) {if (dev->flag != 1) {return -EAGAIN;}}wait_event_interruptible(wqh, dev->flag);if(copy_to_user(buf, dev->buffer, size)!=0) {printk("copy to user error\n");return -EFAULT;}return size;
}ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{struct devices *dev = (struct devices *)filp->private_data;if(copy_from_user(dev->buffer, buf, size)) {printk("copy from user error\n");return -EFAULT;}dev->flag = 1;wake_up_interruptible(&wqh);kill_fasync(&dev->fasync, SIGIO, POLLIN);printk("WRITE: %s\n", dev->buffer);return size;}static __poll_t test_poll(struct file *filp, struct poll_table_struct *p)
{struct devices *dev = (struct devices *)filp->private_data;__poll_t mask = 0;poll_wait(filp, &wqh, p);if (dev->flag == 1) {mask |= POLLIN;}return mask;
}static int test_fasync(int fd, struct file *filp, int on)
{struct devices *dev = (struct devices *)filp->private_data;return fasync_helper(fd, filp, on, &dev->fasync); //对fasync_struct结构体进行初始化
}int test_release(struct inode *inode, struct file *filp)
{printk("dev close!\n");return 0;
}//声明操作函数集合
struct file_operations wq_fops = {.owner = THIS_MODULE,.open = test_open,.read = test_read,.write = test_write,.poll = test_poll,.fasync = test_fasync,.release = test_release,
};//分配初始化miscdevice
struct miscdevice misc_dev = {.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号.name = "qw",//设备文件名.fops = &wq_fops,//操作函数集合
};//加载函数
int test_init(void)
{int ret;//注册miscdeviceret = misc_register(&misc_dev);if (ret < 0) {misc_deregister(&misc_dev);return -1;}qw_dev.flag = 0;return 0;}//卸载函数
void test_exit(void)
{//注销miscdevice	misc_deregister(&misc_dev);
}//声明为模块的入口和出口
module_init(test_init);
module_exit(test_exit);MODULE_LICENSE("GPL");//GPL模块许可证
MODULE_AUTHOR("xin");//作者
MODULE_VERSION("2.0");//版本
MODULE_DESCRIPTION("WQ driver!");//描述信息

将驱动模块加载到内核中后,先运行读程序,发现程序会阻塞,这是因为用while(1)来模拟程序继续处理其他事情。然后另开一个终端运行写程序,读程序才会打印出写程序的数据。

异步IO

相对于同步IO,异步IO不是顺序执行。用户进程进行aio_read系统调用之后,无论内核数据是否准备好,都会直接返回给用户进程,然后用户态进程可以去做别的事情。等到设备数据准备好了,内核直接复制数据给进程,然后从内核向进程发送通知。IO两个阶段,进程都是非阻塞的。异步IO可以在空户空间的glibc库实现,不依赖内核就不举实例了。

总结 

阻塞IO实现简单,但是性能不佳,非阻塞IO虽然不需要阻塞线程,但是他需要轮询操作低效。

IO多路复用有三种实现,select和poll都是使用了轮询的方式,监听文件描述符不能太多。epoll的实现使用了红黑树,增删改文件描述符效率高,并且使用了事件触发机制,不需要进行轮询。

信号驱动IO依赖于信号机制,它对信号的处理需要一定的时间,因此它不适合高速IO操作。

异步IO模型的实现比同步IO模型更加复杂,需要使用操作系统提供的通知机制来处理IO完成的事件,同时也需要考虑到异步IO可能会引入的竞争条件和死锁问题。

参考文章:深入理解Linux的五种IO模型,linux五种IO模型。

相关文章:

Linux驱动实现IO模型

在Linux系统分为内核态和用户态&#xff0c;CPU会在这两个状态之间进行切换。当进行IO操作时&#xff0c;应用程序会使用系统调用进入内核态&#xff0c;内核操作系统会准备好数据&#xff0c;把IO设备的数据加载到内核缓冲区。 然后内核操作系统会把内核缓冲区的数据从内核空…...

wsl2 更新报错问题解决记录

1、问题 win10 中安装的 wsl2&#xff0c;启动 docker desktop 时提示 wsl2 有问题&#xff1a; 于是点击推荐的地址连接到微软&#xff0c;下载 wsl2 的更新文件。之后运行&#xff0c;又报错&#xff1a; 更新被卡住。 2、解决方法 WinR 输入 cmd 打开命令行窗口&#x…...

突破算法迷宫:精选50道-算法刷题指南

前言 在计算机科学和编程领域&#xff0c;算法和数据结构是基础的概念&#xff0c;无论你是一名初学者还是有经验的开发者&#xff0c;都需要掌握它们。本文将带你深入了解一系列常见的算法和数据结构问题&#xff0c;包括二分查找、滑动窗口、链表、二叉树、TopK、设计题、动…...

玩转Mysql系列 - 第26篇:聊聊mysql如何实现分布式锁?

这是Mysql系列第26篇。 本篇我们使用mysql实现一个分布式锁。 分布式锁的功能 分布式锁使用者位于不同的机器中&#xff0c;锁获取成功之后&#xff0c;才可以对共享资源进行操作 锁具有重入的功能&#xff1a;即一个使用者可以多次获取某个锁 获取锁有超时的功能&#xff…...

linux 解压缩命令tar

Tar tar 命令的选项有很多(用 man tar 可以查看到)&#xff0c;但常用的就那么几个选项&#xff0c;下面来举例说明一下&#xff1a; tar -cf all.tar *.jpg 这条命令是将所有.jpg 的文件打成一个名为 all.tar 的包。-c 是表示产生新的包&#xff0c;-f 指 定包的文件名。 …...

OpenAI ChatGPT API 文档之 Embedding

译者注&#xff1a; Embedding 直接翻译为嵌入似乎不太恰当&#xff0c;于是问了一下 ChatGPT&#xff0c;它的回复如下&#xff1a; 在自然语言处理和机器学习领域&#xff0c;"embeddings" 是指将单词、短语或文本转换成连续向量空间的过程。这个向量空间通常被称…...

Java常用类(二)

好久不见&#xff0c;因工作原因&#xff0c;好久没发文了&#xff0c;OldWang 回来了&#xff0c;持续更新Java内容&#xff01;⭐ 不可变和可变字符序列使用陷阱⭐ 时间处理相关类⭐ Date 时间类(java.util.Date)⭐ DateFormat 类和 SimpleDateFormat 类⭐ Calendar 日历类 ⭐…...

Java获取给定月份的前N个月份和前N个季度

描述&#xff1a; 在项目开发过程中&#xff0c;遇到这样一个需求&#xff0c;即&#xff1a;给定某一月份&#xff0c;得到该月份前面的几个月份以及前面的几个季度。例如&#xff1a;给定2023-09&#xff0c;获取该月份前面的前3个月&#xff0c;即2023-08、2023-07、2023-0…...

网页资源加载过程

网页资源加载是指在浏览器中访问一个网页时&#xff0c;浏览器如何获取和显示网页内容的过程。这个过程通常分为以下几个步骤&#xff1a; DNS 解析&#xff1a; 当用户在浏览器中输入一个网址&#xff08;例如&#xff0c;https://www.example.com&#xff09;&#xff0c;浏览…...

使用git config --global设置用户名和邮件,以及git config的全局和局部配置

文章目录 1. 文章引言2. 全局配置2.1 命令方式2.2 配置文件方式 3. 局部配置3.1 命令方式3.2 配置文件方式 4. 总结 1. 文章引言 我们为什么要设置设置用户名和邮件&#xff1f; 我们在注册github&#xff0c;gitlab等时&#xff0c;一般使用用户名或邮箱&#xff1a; 这个用户…...

【C语言】21-指针-3

目录 1. 指针数组1.1 什么是指针数组1.2 如何定义指针数组1.3 如何使用指针数组2. 多重指针2.1 二重指针的定义2.2 二重指针的初始化与赋值2.3 二重指针的使用3. 指针常量、常量指针、指向常量的常指针3.1 概念3.2 const pointer3.3 pointer to a constant3.3.1 (pointer to a …...

解决craco启动react项目卡死在Starting the development server的问题

现象&#xff1a; 原因&#xff1a;craco.config.ts配置文件有问题 经过排查发现Dev开发模式下不能有splitChunk的配置&#xff0c; 解决办法&#xff1a; 加一个生产模式的判断&#xff0c;开发模式不加载splitChunk的配置&#xff0c;仅在生产模式才加载 判断条件代码&#…...

常见的密码学算法都有哪些?

密码学算法是用于保护信息安全的数学方法和技术。它们可以分为多个类别&#xff0c;包括对称加密、非对称加密、哈希函数和数字签名等。以下是一些常见的密码学算法&#xff1a; 1、对称加密算法&#xff1a; AES&#xff08;高级加密标准&#xff09;&#xff1a;一种广泛使…...

云安全【阿里云ECS攻防】

关于VPC的概念还请看&#xff1a;记录一下弹性计算云服务的一些词汇概念 - 火线 Zone-安全攻防社区 一、初始化访问 1、元数据 1.1、SSRF导致读取元数据 如果管理员给ECS配置了RAM角色&#xff0c;那么就可以获得临时凭证 如果配置RAM角色 在获取ram临时凭证的时候&#xff…...

TBSS数据分析

tbss分析基本流程&#xff1a; 步骤一&#xff0c;指标解算&#xff1a;求解出FA&#xff0c;MD&#xff0c;AD&#xff0c;RD指标 #!/bin/bash #基于体素的形态学分析VBA path/media/kui/Passport5T/DATA_help/TBSS/row_data mkdir ${path}/Results_DTI_tbss mkdir ${path}/R…...

【单调队列】 239. 滑动窗口最大值

239. 滑动窗口最大值 解题思路 计算每一个滑动窗口的最大值 关键在于借助单调队列实现窗口对于单调队列 尾部添加元素 头部删除元素添加元素操作&#xff1a;从尾部开始循环对比 删除比当前元素小的元素获取最大值元素 直接获取头部元素删除元素操作 直接删除头部元素 class…...

Spring实例化源码解析之ComponentScanAnnotationParser(四)

上一章我们分析了ConfigurationClassParser&#xff0c;配置类的解析源码分析。在ComponentScans和ComponentScan注解修饰的候选配置类的解析过程中&#xff0c;我们需要深入的了解一下ComponentScanAnnotationParser的parse执行流程&#xff0c;SpringBoot启动类为什么这么写&…...

MySQL - 外键(foreign key)约束的作用和使用

什么是外键约束&#xff1f; 外键&#xff1a;用来让两张表的数据之间建立连接&#xff0c;从而保证数据的一致性和完整性。 外键约束是用于建立两个表之间关系的一种约束&#xff0c;它定义了一个表中的列与另一个表中的列之间的关系。外键约束可以保证数据的完整性和一致性…...

前端开发之服务器的基本概念与初识Ajax

1&#xff0c;服务器的基本概念与初识Ajax 1.1 URL地址的组成部分 1.2 客户端与服务器的通信过程 1.3 网页中如何请求数据 1.4 $.get()函数 1.4.1 $.get()函数的语法 // jQuery 中 $.get() 函数的功能单一&#xff0c;专门用来发起 get 请求&#xff0c;从而将服务器上的资源…...

数据结构排序算法---八大排序复杂度及代码实现

文章目录 一、冒泡排序代码实现 二、直接插入排序代码实现 三、希尔排序代码实现 四、选择排序代码实现 五、堆排序代码实现 六、快速排序代码实现 七、归并排序代码实现 八、计数排序代码实现 稳定性&#xff1a;相同的数据排序后&#xff0c;相对位置是否发生改变 一、冒泡排…...

Android Wi-Fi 连接失败日志分析

1. Android wifi 关键日志总结 (1) Wi-Fi 断开 (CTRL-EVENT-DISCONNECTED reason3) 日志相关部分&#xff1a; 06-05 10:48:40.987 943 943 I wpa_supplicant: wlan0: CTRL-EVENT-DISCONNECTED bssid44:9b:c1:57:a8:90 reason3 locally_generated1解析&#xff1a; CTR…...

Swift 协议扩展精进之路:解决 CoreData 托管实体子类的类型不匹配问题(下)

概述 在 Swift 开发语言中&#xff0c;各位秃头小码农们可以充分利用语法本身所带来的便利去劈荆斩棘。我们还可以恣意利用泛型、协议关联类型和协议扩展来进一步简化和优化我们复杂的代码需求。 不过&#xff0c;在涉及到多个子类派生于基类进行多态模拟的场景下&#xff0c;…...

蓝桥杯 2024 15届国赛 A组 儿童节快乐

P10576 [蓝桥杯 2024 国 A] 儿童节快乐 题目描述 五彩斑斓的气球在蓝天下悠然飘荡&#xff0c;轻快的音乐在耳边持续回荡&#xff0c;小朋友们手牵着手一同畅快欢笑。在这样一片安乐祥和的氛围下&#xff0c;六一来了。 今天是六一儿童节&#xff0c;小蓝老师为了让大家在节…...

全球首个30米分辨率湿地数据集(2000—2022)

数据简介 今天我们分享的数据是全球30米分辨率湿地数据集&#xff0c;包含8种湿地亚类&#xff0c;该数据以0.5X0.5的瓦片存储&#xff0c;我们整理了所有属于中国的瓦片名称与其对应省份&#xff0c;方便大家研究使用。 该数据集作为全球首个30米分辨率、覆盖2000–2022年时间…...

学校招生小程序源码介绍

基于ThinkPHPFastAdminUniApp开发的学校招生小程序源码&#xff0c;专为学校招生场景量身打造&#xff0c;功能实用且操作便捷。 从技术架构来看&#xff0c;ThinkPHP提供稳定可靠的后台服务&#xff0c;FastAdmin加速开发流程&#xff0c;UniApp则保障小程序在多端有良好的兼…...

python如何将word的doc另存为docx

将 DOCX 文件另存为 DOCX 格式&#xff08;Python 实现&#xff09; 在 Python 中&#xff0c;你可以使用 python-docx 库来操作 Word 文档。不过需要注意的是&#xff0c;.doc 是旧的 Word 格式&#xff0c;而 .docx 是新的基于 XML 的格式。python-docx 只能处理 .docx 格式…...

华为云Flexus+DeepSeek征文|DeepSeek-V3/R1 商用服务开通全流程与本地部署搭建

华为云FlexusDeepSeek征文&#xff5c;DeepSeek-V3/R1 商用服务开通全流程与本地部署搭建 前言 如今大模型其性能出色&#xff0c;华为云 ModelArts Studio_MaaS大模型即服务平台华为云内置了大模型&#xff0c;能助力我们轻松驾驭 DeepSeek-V3/R1&#xff0c;本文中将分享如何…...

佰力博科技与您探讨热释电测量的几种方法

热释电的测量主要涉及热释电系数的测定&#xff0c;这是表征热释电材料性能的重要参数。热释电系数的测量方法主要包括静态法、动态法和积分电荷法。其中&#xff0c;积分电荷法最为常用&#xff0c;其原理是通过测量在电容器上积累的热释电电荷&#xff0c;从而确定热释电系数…...

使用Spring AI和MCP协议构建图片搜索服务

目录 使用Spring AI和MCP协议构建图片搜索服务 引言 技术栈概览 项目架构设计 架构图 服务端开发 1. 创建Spring Boot项目 2. 实现图片搜索工具 3. 配置传输模式 Stdio模式&#xff08;本地调用&#xff09; SSE模式&#xff08;远程调用&#xff09; 4. 注册工具提…...

SQL慢可能是触发了ring buffer

简介 最近在进行 postgresql 性能排查的时候,发现 PG 在某一个时间并行执行的 SQL 变得特别慢。最后通过监控监观察到并行发起得时间 buffers_alloc 就急速上升,且低水位伴随在整个慢 SQL,一直是 buferIO 的等待事件,此时也没有其他会话的争抢。SQL 虽然不是高效 SQL ,但…...