Linux驱动开发基础__POLL机制

news2024/10/8 15:34:49

目录

1 适用场景

2 POLL机制的内核代码详解

2.1 sys_poll 函数 

2.2  do_sys_poll 函数 

2.3 do_poll函数

3 poll机制使用流程

4 驱动编程

5 应用编程

6 代码

6.1 gpio_key_drv.c

6.2 button_test.c

6.3 Makefile

可以看 字符设备驱动程序之poll机制 那篇文章中的机制分析以及代码去理解POLL机制，看完那篇文章也就理解POLL机制了，下面的这篇文章也可以不看。

1 适用场景

在前面引入中断时，我们曾经举过一个例子：妈妈怎么知道卧室里小孩醒了？ 
poll 方式：妈妈要干很多活，但是可以陪小孩睡一会，定个闹钟，要浪费点时间，但是可以继续干活。妈妈要么是被小孩吵醒，要么是被闹钟吵醒。 
使用休眠-唤醒的方式等待某个事件发生时，有一个缺点：等待的时间可能很久。我们可以加上一个超时时间，这时就可以使用 poll 机制。

  • APP 不知道驱动程序中是否有数据，可以先调用 poll 函数查询一下，poll 函数可以传入超时时间； 
  • APP 进入内核态，调用到驱动程序的 poll 函数，如果有数据的话立刻返回； 
  • 如果发现没有数据时就休眠一段时间； 
  • 当有数据时，比如当按下按键时，驱动程序的中断服务程序被调用，它会记录数据、唤醒 APP； 
  • 当超时时间到了之后，内核也会唤醒 APP； 
  •  APP 根据 poll 函数的返回值就可以知道是否有数据，如果有数据就调用read 得到数据。 

2 POLL机制的内核代码详解

Linux APP 系统调用，基本都可以在它的名字前加上“sys_”前缀，这就是它在内核中对应的函数。比如系统调用 open、read、write、poll，与之对应的内核函数为：sys_open、sys_read、sys_write、sys_poll。 

对于系统调用 poll 或 select，它们对应的内核函数都是 sys_poll。分析sys_poll，即可理解 poll 机制。 

2.1 sys_poll 函数 

sys_poll 位于 fs/select.c 文件中，代码如下：

SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds, 
    int, timeout_msecs) 
{ 
  struct timespec64 end_time, *to = NULL; 
  int ret; 
 
  if (timeout_msecs >= 0) { 
    to = &end_time; 
    poll_select_set_timeout(to, timeout_msecs / MSEC_PER_SEC, 
      NSEC_PER_MSEC * (timeout_msecs % MSEC_PER_SEC)); 
  } 
 
  ret = do_sys_poll(ufds, nfds, to); 
……

SYSCALL_DEFINE3 是一个宏，它定义于 include/linux/syscalls.h，展开后就有 sys_poll 函数。 
sys_poll 对超时参数稍作处理后，直接调用 do_sys_poll。 

2.2  do_sys_poll 函数 

do_sys_poll 位于 fs/select.c 文件中，我们忽略其他代码，只看关键部分：

int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, 
    struct timespec64 *end_time) 
{ 
…… 
  poll_initwait(&table); 
  fdcount = do_poll(head, &table, end_time); 
  poll_freewait(&table); 
…… 
}

poll_initwait 函数非常简单，它初始化一个 poll_wqueues 变量 table：

poll_initwait 
init_poll_funcptr(&pwq->pt, __pollwait); 
pt->qproc = qproc; 

即 table->pt->qproc = __pollwait，__pollwait 将在驱动的 poll 函数里用到。do_poll 函数才是核心，继续看代码。 

2.3 do_poll函数

do_poll 函数位于 fs/select.c 文件中，这是 POLL 机制中最核心的代码，贴图如下：

① 从这里开始，将会导致驱动程序的 poll 函数被第一次调用。 沿着②③④⑤，你可以看到：驱动程序里的 poll_wait 会调用__pollwait函数把线程放入某个队列。 
当执行完①之后，在⑥或⑦处，pt->_qproc 被设置为 NULL，所以第二次调用驱动程序的 poll 时，不会再次把线程放入某个队列里。 
⑧ 如果驱动程序的 poll 返回有效值，则 count 非 0，跳出循环； 
⑨ 否则休眠一段时间；当休眠时间到，或是被中断唤醒时，会再次循环、再次调用驱动程序的 poll。 
回顾 APP 的代码，APP 可以指定“想等待某些事件”，poll 函数返回后，可以知道“发生了哪些事件”： 

 驱动程序里怎么体现呢？在上上一个图中，看②位置处，细说如下： 

 3 poll机制使用流程

妈妈进入房间时，会先看小孩醒没醒，闹钟响之后走出房间之前又会再看小孩醒没醒。注意：看了 2 次小孩！ POLL 机制也是类似的，流程如下：

函数执行流程如上图①～⑧所示，重点从③开始看。假设一开始无按键数据： 
③APP 调用 poll 之后，进入内核态； 
④导致驱动程序的 drv_poll 被调用： 
注意，drv_poll 要把自己这个线程挂入等待队列 wq 中；假设不放入队列里，那以后发生中断时，中断服务程序去哪里找到你嘛？ 
drv_poll 还会判断一下：有没有数据啊？返回这个状态。 
⑤当前没有数据，则休眠一会； 
⑥过程中，按下了按键，发生了中断：  在中断服务程序里记录了按键值，并且从 wq 中把线程唤醒了。 
⑦从休眠中被唤醒，继续执行 for 循环，再次调用 drv_poll： drv_poll 返回数据状态 
⑧哦，你有数据，那从内核态返回到应用态吧 
⑨APP 调用 read 函数读数据 
如果一直没有数据，调用流程也是类似的，重点从③开始看，如下： 
③ APP 调用 poll 之后，进入内核态； 
④  导致驱动程序的 drv_poll 被调用： 
注意，drv_poll 要把自己这个线程挂入等待队列 wq 中；假设不放入队列里，那以后发生中断时，中断服务程序去哪里找到你嘛？ 
drv_poll 还会判断一下：有没有数据啊？返回这个状态。 
⑤  假设当前没有数据，则休眠一会； 
⑥  在休眠过程中，一直没有按下了按键，超时时间到：内核把这个线程唤醒； 
⑦  线程从休眠中被唤醒，继续执行 for 循环，再次调用 drv_poll：drv_poll 返回数据状态 
⑧  哦，你还是没有数据，但是超时时间到了，那从内核态返回到应用态吧 
⑨  APP 不能调用 read 函数读数据 
注意几点： 

  • drv_poll 要把线程挂入队列 wq，但是并不是在 drv_poll 中进入休眠，而是在调用 drv_poll 之后休眠 
  • drv_poll 要返回数据状态 
  • APP 调用一次 poll，有可能会导致 drv_poll 被调用 2 次 
  • 线程被唤醒的原因有 2：中断发生了去队列 wq 中把它唤醒，超时时间到了内核把它唤醒 
  • APP 要判断 poll 返回的原因：有数据，还是超时。有数据时再去调用 read函数。 

4 驱动编程

使用 poll 机制时，驱动程序的核心就是提供对应的 drv_poll 函数。在drv_poll 函数中要做 2 件事： 
把当前线程挂入队列 wq：poll_wait 
a)  APP 调用一次 poll，可能导致 drv_poll 被调用 2 次，但是我们并不需要把当前线程挂入队列 2 次。 
b)  可以使用内核的函数 poll_wait 把线程挂入队列，如果线程已经在队列里了，它就不会再次挂入。 
返回设备状态： 
APP 调用 poll 函数时，有可能是查询“有没有数据可以读”：POLLIN，也有可能是查询“你有没有空间给我写数据”：POLLOUT。所以 drv_poll 要返回自己的当前状态：(POLLIN | POLLRDNORM) 或 (POLLOUT | POLLWRNORM)。 
a)  POLLRDNORM 等同于 POLLIN，为了兼容某些 APP 把它们一起返回。 
b)  POLLWRNORM 等同于 POLLOUT  ，为了兼容某些 APP 把它们一起返
回。 
APP 调用 poll 后，很有可能会休眠。对应的，在按键驱动的中断服务程序中，也要有唤醒操作。 
驱动程序中 poll 的代码如下：

static unsigned int gpio_key_drv_poll(struct file *fp, poll_table * wait) 
{ 
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
  poll_wait(fp, &gpio_key_wait, wait); 
  return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM; 
}

5 应用编程

注意：APP 可以调用 poll 或 select 函数，这 2 个函数的作用是一样的。 poll/select 函数可以监测多个文件，可以监测多种事件： 

 在调用 poll 函数时，要指明： 
⚫  你要监测哪一个文件：哪一个 fd 
⚫  你想监测这个文件的哪种事件：是 POLLIN、还是 POLLOUT 
最后，在 poll 函数返回时，要判断状态。 
应用程序代码如下：

struct pollfd fds[1]; 
int timeout_ms = 5000; 
int ret; 
 
fds[0].fd = fd; 
fds[0].events = POLLIN; 
 
ret = poll(fds, 1, timeout_ms); 
if ((ret == 1) && (fds[0].revents & POLLIN)) 
{ 
  read(fd, &val, 4); 
  printf("get button : 0x%x\n", val); 
}

6 代码

6.1 gpio_key_drv.c

#include <linux/module.h>
#include <linux/poll.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>


struct gpio_key{
	int gpio;
	struct gpio_desc *gpiod;
	int flag;
	int irq;
} ;

static struct gpio_key *gpio_keys_100ask;

/* 主设备号                                                                 */
static int major = 0;
static struct class *gpio_key_class;

/* 环形缓冲区 */
#define BUF_LEN 128
static int g_keys[BUF_LEN];
static int r, w;

#define NEXT_POS(x) ((x+1) % BUF_LEN)

static int is_key_buf_empty(void)
{
	return (r == w);
}

static int is_key_buf_full(void)
{
	return (r == NEXT_POS(w));
}

static void put_key(int key)
{
	if (!is_key_buf_full())
	{
		g_keys[w] = key;
		w = NEXT_POS(w);
	}
}

static int get_key(void)
{
	int key = 0;
	if (!is_key_buf_empty())
	{
		key = g_keys[r];
		r = NEXT_POS(r);
	}
	return key;
}


static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);

/* 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t gpio_key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	int err;
	int key;
	
	wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());
	key = get_key();
	err = copy_to_user(buf, &key, 4);
	
	return 4;
}

static unsigned int gpio_key_drv_poll(struct file *fp, poll_table * wait)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	poll_wait(fp, &gpio_key_wait, wait);
	return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
}


/* 定义自己的file_operations结构体                                              */
static struct file_operations gpio_key_drv = {
	.owner	 = THIS_MODULE,
	.read    = gpio_key_drv_read,
	.poll    = gpio_key_drv_poll,
};


static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
	struct gpio_key *gpio_key = dev_id;
	int val;
	int key;
	
	val = gpiod_get_value(gpio_key->gpiod);
	

	printk("key %d %d\n", gpio_key->gpio, val);
	key = (gpio_key->gpio << 8) | val;
	put_key(key);
	wake_up_interruptible(&gpio_key_wait);
	
	return IRQ_HANDLED;
}

/* 1. 从platform_device获得GPIO
 * 2. gpio=>irq
 * 3. request_irq
 */
static int gpio_key_probe(struct platform_device *pdev)
{
	int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;
	enum of_gpio_flags flag;
		
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	count = of_gpio_count(node);
	if (!count)
	{
		printk("%s %s line %d, there isn't any gpio available\n", __FILE__, __FUNCTION__, __LINE__);
		return -1;
	}

	gpio_keys_100ask = kzalloc(sizeof(struct gpio_key) * count, GFP_KERNEL);
	for (i = 0; i < count; i++)
	{
		gpio_keys_100ask[i].gpio = of_get_gpio_flags(node, i, &flag);
		if (gpio_keys_100ask[i].gpio < 0)
		{
			printk("%s %s line %d, of_get_gpio_flags fail\n", __FILE__, __FUNCTION__, __LINE__);
			return -1;
		}
		gpio_keys_100ask[i].gpiod = gpio_to_desc(gpio_keys_100ask[i].gpio);
		gpio_keys_100ask[i].flag = flag & OF_GPIO_ACTIVE_LOW;
		gpio_keys_100ask[i].irq  = gpio_to_irq(gpio_keys_100ask[i].gpio);
	}

	for (i = 0; i < count; i++)
	{
		err = request_irq(gpio_keys_100ask[i].irq, gpio_key_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "100ask_gpio_key", &gpio_keys_100ask[i]);
	}

	/* 注册file_operations 	*/
	major = register_chrdev(0, "100ask_gpio_key", &gpio_key_drv);  /* /dev/gpio_key */

	gpio_key_class = class_create(THIS_MODULE, "100ask_gpio_key_class");
	if (IS_ERR(gpio_key_class)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		unregister_chrdev(major, "100ask_gpio_key");
		return PTR_ERR(gpio_key_class);
	}

	device_create(gpio_key_class, NULL, MKDEV(major, 0), NULL, "100ask_gpio_key"); /* /dev/100ask_gpio_key */
        
    return 0;
    
}

static int gpio_key_remove(struct platform_device *pdev)
{
	//int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;

	device_destroy(gpio_key_class, MKDEV(major, 0));
	class_destroy(gpio_key_class);
	unregister_chrdev(major, "100ask_gpio_key");

	count = of_gpio_count(node);
	for (i = 0; i < count; i++)
	{
		free_irq(gpio_keys_100ask[i].irq, &gpio_keys_100ask[i]);
	}
	kfree(gpio_keys_100ask);
    return 0;
}


static const struct of_device_id ask100_keys[] = {
    { .compatible = "100ask,gpio_key" },
    { },
};

/* 1. 定义platform_driver */
static struct platform_driver gpio_keys_driver = {
    .probe      = gpio_key_probe,
    .remove     = gpio_key_remove,
    .driver     = {
        .name   = "100ask_gpio_key",
        .of_match_table = ask100_keys,
    },
};

/* 2. 在入口函数注册platform_driver */
static int __init gpio_key_init(void)
{
    int err;
    
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	
    err = platform_driver_register(&gpio_keys_driver); 
	
	return err;
}

/* 3. 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
 *     卸载platform_driver
 */
static void __exit gpio_key_exit(void)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

    platform_driver_unregister(&gpio_keys_driver);
}


/* 7. 其他完善：提供设备信息，自动创建设备节点                                     */

module_init(gpio_key_init);
module_exit(gpio_key_exit);

MODULE_LICENSE("GPL");

6.2 button_test.c


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <poll.h>

/*
 * ./button_test /dev/100ask_button0
 *
 */
int main(int argc, char **argv)
{
	int fd;
	int val;
	struct pollfd fds[1];
	int timeout_ms = 5000;
	int ret;
	
	/* 1. 判断参数 */
	if (argc != 2) 
	{
		printf("Usage: %s <dev>\n", argv[0]);
		return -1;
	}

	/* 2. 打开文件 */
	fd = open(argv[1], O_RDWR);
	if (fd == -1)
	{
		printf("can not open file %s\n", argv[1]);
		return -1;
	}

	fds[0].fd = fd;
	fds[0].events = POLLIN;
	

	while (1)
	{
		/* 3. 读文件 */
		ret = poll(fds, 1, timeout_ms);
		if ((ret == 1) && (fds[0].revents & POLLIN))
		{
			read(fd, &val, 4);
			printf("get button : 0x%x\n", val);
		}
		else
		{
			printf("timeout\n");
		}
	}
	
	close(fd);
	
	return 0;
}

6.3 Makefile


# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH,          比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH,          比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin 
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
#       请参考各开发板的高级用户使用手册

KERN_DIR =  # 板子所用内核源码的目录

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	$(CROSS_COMPILE)gcc -o button_test button_test.c
clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order  button_test

# 参考内核源码drivers/char/ipmi/Makefile
# 要想把a.c, b.c编译成ab.ko, 可以这样指定:
# ab-y := a.o b.o
# obj-m += ab.o



obj-m += gpio_key_drv.o

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/191034.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【认证相关】FTA

【认证相关】FTA

FTA 测试需要涉及的工作与流程测试大致流程及涉及的工作送测Lab 之前需做的准备工作项目与测试样机基本信息如下信息请填写发给MTK&#xff0c;以便MTK 了解基本的认证项目与产品信息PICS 相关MTK 会提供一份Chip 的default PICS&#xff0c;但是客户还需要自行修改一些项的Val…
阅读更多...
分享154个ASP源码，总有一款适合您

分享154个ASP源码，总有一款适合您

ASP源码 分享154个ASP源码&#xff0c;总有一款适合您 下面是文件的名字&#xff0c;我放了一些图片&#xff0c;文章里不是所有的图主要是放不下...&#xff0c; 154个ASP源码下载链接&#xff1a;https://pan.baidu.com/s/1Jt3X-WAZv-rZswzjwyEtSQ?pwdt46u 提取码&#x…
阅读更多...
【C++初阶】七、STL---vector模拟实现

【C++初阶】七、STL---vector模拟实现

目录 一、模拟实现接口总览 1.1 接口总览 1.2 vector整体框架 1.3 vector成员变量介绍 二、vector模拟实现 2.1 构造函数 2.1.1 无参构造 2.1.2 迭代器区间构造 2.1.3 n个val构造 2.1.4 拷贝构造 2.2 赋值运算符重载 2.2.1 传统写法 2.2.2 现代写法 2.3 析构函数…
阅读更多...
蓝桥杯刷题018——和与乘积（贪心）

蓝桥杯刷题018——和与乘积（贪心）

2021国赛&#xff1a;和与乘积 题目描述 给定一个数列 &#xff0c;问有多少个区间[L,R] 满足区间内元素的乘积等于他们的和&#xff0c;即 输入描述 输入第一行包含一个整数 n&#xff0c;表示数列的长度。 第二行包含 n 个整数&#xff0c;依次表示数列中的数 a1​,a2​,⋯,a…
阅读更多...
【Vue】模板语法——文本插值

【Vue】模板语法——文本插值

一、模板语法什么是模板语法Vue 使用一种基于 HTML 的模板语法&#xff0c;使我们能够声明式地将其组件实例的数据绑定到呈现的 DOM 上。所有的 Vue 模板都是语法层面合法的 HTML&#xff0c;可以被符合规范的浏览器和 HTML 解析器解析。在底层机制中&#xff0c;Vue 会将模板编…
阅读更多...
(十四)docker安装nacos

(十四)docker安装nacos

一、简介 操作系统&#xff1a;Linux CentOS 7.3 64位 docker版本&#xff1a;19.03.8 nacos版本&#xff1a;默认拉取最新版本 二、实践 1、拉取镜像 docker pull nacos/nacos-server 2、运行容器 docker run --name nacos -p 8848:8848 \ --privilegedtrue \ --restar…
阅读更多...
二、什么是GStreamer

二、什么是GStreamer

GStreamer是一个用于创建流媒体应用程序的框架。基本的设计来自俄勒冈研究生院的视频管道&#xff0c;还有一些来自DirectShow的想法。 GStreamer的开发框架使编写任何类型的流媒体应用程序成为可能。GStreamer框架旨在使编写处理音频或视频或两者同时处理的应用程序变得容易。…
阅读更多...
01_学习springdoc的基本使用

01_学习springdoc的基本使用

文章目录1 什么是 springdoc ?2 springdoc 基本信息3 maven 依赖4 正文来袭4.1 给 Controller 加注解4.2 给 Model 加注解5 大功告成1 什么是 springdoc ? 网上冲浪&#x1f3c4;&#x1f3fb;‍♂️时&#xff0c;无意间发现 java web 应用程序的在线接口文档&#xff0c;除…
阅读更多...
开源大数据分析平台的内容有什么？

开源大数据分析平台的内容有什么？

在大数据时代&#xff0c;做好数据管理是非常重要的一个步骤。可以给企业做出正确的经营决策&#xff0c;指引新的发展方向。因此&#xff0c;随着数字化时代的到来&#xff0c;很多企业都倾向于寻找适宜的开源大数据分析平台&#xff0c;以此提升企业办公协作效率&#xff0c;…
阅读更多...
【184】Win10下Java8调用Python的face_recognition库来实现人脸识别

【184】Win10下Java8调用Python的face_recognition库来实现人脸识别

前言 face_recognition 是一个开源的、人脸识别的Python库。本文讲解了在 Windows 10操作系统上&#xff0c;使用 Java8 来调用 Python 的 face_recognition 库来实现人脸识别。虽然 Java8 有 Jython&#xff0c;但是由于截至发文时 Jython 支持的版本太老&#xff08;只有Pyt…
阅读更多...
oracle——列表分页查询(原理)

oracle——列表分页查询(原理)

文章目录前言数据表的准备分页sql1、简单分页实现2、排序分页3、排序优化前言 在平时的开发中&#xff0c;Oracle的分页查询用的特别多&#xff0c;接下来不止是说使用&#xff0c;更讲分页sql写法的原理。 数据表的准备 创建一张数据表&#xff0c;并填充大量的数据。 cre…
阅读更多...
大数据技术架构(组件)12——Hive：判断函数

大数据技术架构(组件)12——Hive：判断函数

1.4.6、判断函数1.4.6.1、ifselect if(11,a,b),if(12,a,b) ;1.4.6.2、isnullselect isnull(1),isnull(null);1.4.6.3、isnotnullselect isnotnull(1),isnotnull(null);1.4.6.4、nvlselect nvl(1,1),nvl(null,1);1.4.6.5、coalesceselect coalesce(1,null,2,3,null,4,null),coal…
阅读更多...
感谢第三弹 | 开启地铁国产化浪潮 GBASE获多方城市“地下动脉”肯定

感谢第三弹 | 开启地铁国产化浪潮 GBASE获多方城市“地下动脉”肯定

岁末年初&#xff0c;GBASE收到了来自深圳地铁、高新现代智能系统股份有限公司、深圳达实智能股份有限公司等客户及合作伙伴发来的荣誉证书及感谢信。作为亲密无间的战友&#xff0c;GBASE携手高新现代、达实智能在深圳地铁CLC、ACC、AFC多个条线项目中通力合作&#xff0c;助力…
阅读更多...
背包问题学习

背包问题学习

01背包 01背包&#xff08;0-1 Knapsack Problem&#xff09; 有NNN件物品和一个容量为VVV的背包。放入第iii件物品耗费的费用是CiC_iCi​,得到的价值为WiW_iWi​。求解将哪些物品装入背包可以使价值总和最大 设F[i,v]F\left[i,v\right]F[i,v]表示前iii件物品敲好放入一个容量…
阅读更多...
软件防错设计

软件防错设计

出现非预期错误的原因解决方案原理介绍断根原理原理&#xff1a;将可能造成人错误的原因/条件从根本上排除断绝掉。通过冗余设计&#xff0c;屏蔽掉其中9种错误的方式&#xff1b;案例&#xff1a;USB的SD卡防写开关。4种可能性断根设计为只有1种可能是正确的。软件设计&#x…
阅读更多...
Linux学习之环境准备【Vm+Centos】

Linux学习之环境准备【Vm+Centos】

文章目录前言一 VMware Workstation17 Pro下载和安装1.1 Vm下载指南1.2 VM安装指南二 Centos7安装2.1 装机器2.2 装系统三 补充内容3.1 卸载Centos前言 工欲善其事&#xff0c;必先利其器&#xff0c;我们要学习Linux当然需要Linux的环境由于大部分人使用的是Windows系统无法进…
阅读更多...
介绍OAuth2

介绍OAuth2

目录 一、什么是OAuth2&#xff1f; 二、OAuth2中的角色 1、资源所有者 2、资源服务器 3、客户 4、授权服务器 三、认证流程 四、OAuth2授权方式 注&#xff1a;使用令牌方式的优点 1、授权码 2、隐藏方式 3、密码方式 4、凭证方式 一、什么是OAuth2&#xff1f…
阅读更多...
深入浅出ConcurrentHashMap1.8

深入浅出ConcurrentHashMap1.8

前言 HashMap是我们平时开发过程中用的比较多的集合&#xff0c;但它是非线程安全的&#xff0c;在涉及到多线程并发的情况&#xff0c;进行get操作有可能会引起死循环&#xff0c;导致CPU利用率接近100%。 final HashMap<String, String> map new HashMap<String,…
阅读更多...
基于Springboot搭建java项目（二十四）——权限认证框架SpringSecurity

基于Springboot搭建java项目（二十四）——权限认证框架SpringSecurity

权限认证框架SpringSecurity 一、为什么要做权限认证 在WEB开发的过程当中&#xff0c;安全一直是很重要的一方面。安全和直接的业务是没有直接挂钩的&#xff0c;但是在业务实现的初期如果没有考虑的安全性的化&#xff0c;在后期迭代的时候就会出现很多的问题。例如存在着安…
阅读更多...
4.1--贪心--活动安排问题

4.1--贪心--活动安排问题

今天开始&#xff0c;快速过一遍贪心&#xff0c;贪心要比动态规划简单许多&#xff0c;但是&#xff0c;我们也要理解其中的证明过程 贪心算法采用自顶向下&#xff0c;以迭代的方法做出相继的贪心选择&#xff0c;每做一次贪心选择就将所求问题简化为一个规模更小的子问题&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023