lv14 信号量、互斥锁、并发控制机制选择

1 信号量：基于阻塞的并发控制机制

a.定义信号量

struct semaphore sem;

b.初始化信号量

void sema_init(struct semaphore *sem, int val);

c.获得信号量P

int down(struct semaphore *sem);//深度睡眠
int down_interruptible(struct semaphore *sem);//浅度睡眠

d.释放信号量V

void up(struct semaphore *sem);

适用场合：任务上下文之间且临界区执行时间较长时的互斥或同步问题

#include <linux/semaphore.h>

注意：pv操作成对出现

1.1 示例

新建信号量，在init中初始化，read、write、poll、ioctl函数中添加pv操作

mychar_sema.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>


#include "mychar.h"

#define BUF_LEN 100

#define MYCHAR_DEV_CNT 3

int major = 11;
int minor = 0;
int mychar_num  = MYCHAR_DEV_CNT;

//新建结构体类型
struct mychar_dev
{
	struct cdev mydev;
	char mydef_buf[BUF_LEN];  //相当于结构体的私有变量
	int curlen;          //相当于结构体的私有变量
	struct semaphore sem; //定义信号量
	wait_queue_head_t rq; //等待读队列
	wait_queue_head_t wq; //等待写队列

	struct fasync_struct *pasync_obj;  //实现异步通知机制的数据结构

};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	//利用private_data私有变量来指向全局变量结构体地址
	pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));
    printk("mychar_open is called\n");
    return 0;
}

int mychar_close(struct inode *pnode, struct file *pfile)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

    printk("mychar_close is called\n");
	if(pmydev->pasync_obj != NULL)
	{
		fasync_helper(-1,pfile,0,&pmydev->pasync_obj);  //则调用fasync_helper函数来取消异步通知
	}
    return 0;
}


ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{
	int ret = 0;
	int size = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	down(&pmydev->sem);
	if(pmydev->curlen <= 0)
	{
		if(filp->f_flags & O_NONBLOCK)
		{//非阻塞
			up(&pmydev->sem);
			printk("O_NONBLOCK No Data Read\n");
			return -1;
		}
		else
		{//阻塞
			up(&pmydev->sem);
			ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
			if(ret)
			{
				printk("Wake up by signal\n");
				return -ERESTARTSYS;
			}
			down(&pmydev->sem);
		}
	}

 	if(count > pmydev->curlen)
	{
		size = pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将内核空间中的数据复制到用户空间
	ret = copy_to_user(pbuf,pmydev->mydef_buf,size);
	if(ret)
	{
		up(&pmydev->sem);
		printk("copy_to_user failed\n");
		return -1;
	}
	//读完之后把后面的内容再拷贝过来，同时更新curlen
	memcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);
	pmydev->curlen = pmydev->curlen - size;
	up(&pmydev->sem);
	wake_up_interruptible(&pmydev->wq);

	return size;

}

ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{

	int size = 0;
	int ret  = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	down(&pmydev->sem);
	if(pmydev->curlen >= BUF_LEN)
	{
		if(filp->f_flags & O_NONBLOCK)
		{
			up(&pmydev->sem);
			printk("O_NONBLOCK Can not write data\n");
			return -1;
		}
		else
		{
			up(&pmydev->sem);  //不能让write函数拿着资源睡眠，否则其他无法拿到资源了
			ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);
			if(ret)
			{
				printk("wake up by signal\n");
				return -ERESTARTSYS;
			}
			down(&pmydev->sem);
		}
	}

	if(count > BUF_LEN - pmydev->curlen)
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将用户空间中的数据复制到内核空间中
	ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);
	if(ret)
	{
		up(&pmydev->sem);
		printk("copy_from_user failed\n");
		return -1;
	}
    //更新curlen
	pmydev->curlen = pmydev->curlen + size;

	up(&pmydev->sem);
	wake_up_interruptible(&pmydev->rq);

	//数据写成功发送可读信号（同样读函数也可以实现）
	if(pmydev->pasync_obj != NULL)
	{
		kill_fasync(&pmydev->pasync_obj,SIGIO,POLL_IN);
	}
	return size;
}

long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;


	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret,&maxlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
            down(&pmydev->sem);
			ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
            up(&pmydev->sem);
			if(ret)
			{
				printk("copy_to_user CURLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int mychar_poll(struct file *filp, poll_table *ptb)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;
	unsigned int mask = 0;

	//将等待队列头添加至poll_table表中
	poll_wait(filp, &pmydev->rq,ptb);
	poll_wait(filp, &pmydev->wq,ptb);
	
	down(&pmydev->sem);
	if(pmydev->curlen > 0) //有数据可读
	{
		mask |= POLLIN | POLLRDNORM;
	}
	if(pmydev->curlen < BUF_LEN) //有空间可写
	{
		mask |= POLLOUT | POLLWRNORM;
	}
	up(&pmydev->sem);

	return mask;
	
	
}

//使用pmydev->pasync_obj作为异步通知对象进行注册
int mychar_fasync(int fd,struct file *filp,int mode)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	return fasync_helper(fd,filp,mode,&pmydev->pasync_obj);
}

//结构体初始化:部分变量赋值初始化
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = mychar_open,
    .release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
	.unlocked_ioctl = mychar_ioctl,
	.poll = mychar_poll,
	.fasync = mychar_fasync,
};

int mychar_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major, minor);

    /* 申请设备号 */
    ret = register_chrdev_region(devno, mychar_num, "mychar");
    if (ret) {
        ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
        if (ret) {
            printk("get devno failed\n");
            return -1;
        }
		major = MAJOR(devno); // 容易遗漏，注意
    }

    /* 给struct cdev对象指定操作函数集 */
    cdev_init(&gmydev.mydev, &myops);

    /* 将 struct cdev对象添加到内核对应的数据结构里 */
    gmydev.mydev.owner = THIS_MODULE;
    cdev_add(&gmydev.mydev, devno, 1);

	//初始化队列
	init_waitqueue_head(&(gmydev.rq));
	init_waitqueue_head(&(gmydev.wq));
	//初始化信号量
	sema_init(&gmydev.sem, 1);	

    return 0;
}

void __exit mychar_exit(void)
{
    dev_t devno = MKDEV(major, minor);

    cdev_del(&gmydev.mydev);

    unregister_chrdev_region(devno, mychar_num);
	

}

//表示支持GPL的开源协议
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

Makefile

ifeq ($(KERNELRELEASE),)

ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)


modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install

clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions

else
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.o
obj-m += openonce_atomic.o
obj-m += openonce_spinlock.o
obj-m += mychar_sema.o

endif

 testmychar_signal.c

测试函数不需要进行大的修改，直接拿以前的来测试，主要目的可以让函数打开字符设备的时候可以实现并发，不会出现竞态

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/select.h>
#include <errno.h>
#include <signal.h>

#include "mychar.h"
#include <stdio.h>

int fd = -1;

void sigio_handler(int signo);

int main(int argc,char *argv[])
{

	int flg = 0;

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}

	signal(SIGIO,sigio_handler);

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}
		
	//将文件描述符fd设置为异步通知模式，并将当前进程的PID设置为接收异步通知的进程
	fcntl(fd,F_SETOWN,getpid());  //数将当前进程的PID设置为fd的拥有者
	flg = fcntl(fd,F_GETFL);      //取fd的标志位
	flg |= FASYNC;                //然后使用按位或运算符将FASYNC标志位添加到标志中
	fcntl(fd,F_SETFL,flg);        //将flg（即带有FASYNC标志位的标志）设置为fd的标志位，从而使fd进入异步通知模式

	while(1)
	{	
		
	}


	close(fd);
	fd = -1;
	return 0;
}


void sigio_handler(int signo)
{
	char buf[8] = "";
	read(fd,buf,8);
	printf("buf=%s\n",buf);
}

编译

 插入内核模块

测试并发效果

2 互斥锁：基于阻塞的互斥机制

可以理解为特殊的信号量，只能解决单个资源控制。

a.初始化

struct mutex my_mutex; 
mutex_init(&my_mutex);

b.获取互斥体

void mutex_lock(struct mutex *lock);

c.释放互斥体

void mutex_unlock(struct mutex *lock);

 操作步骤：

定义对应类型的变量

初始化对应变量

P/加锁

临界区

V/解锁

#include <linux/mutex.h>

适用场合：任务上下文之间且临界区执行时间较长时的互斥问题。

1.2 示例

mychar_mutex.c

新建信号量，在init中初始化，read、write、poll、ioctl函数中添加pv操作

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>


#include "mychar.h"

#define BUF_LEN 100

#define MYCHAR_DEV_CNT 3

int major = 11;
int minor = 0;
int mychar_num  = MYCHAR_DEV_CNT;

//新建结构体类型
struct mychar_dev
{
	struct cdev mydev;
	char mydef_buf[BUF_LEN];  //相当于结构体的私有变量
	int curlen;          //相当于结构体的私有变量
	struct mutex lock;  //定义互斥锁
	wait_queue_head_t rq; //等待读队列
	wait_queue_head_t wq; //等待写队列

	struct fasync_struct *pasync_obj;  //实现异步通知机制的数据结构

};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	//利用private_data私有变量来指向全局变量结构体地址
	pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));
    printk("mychar_open is called\n");
    return 0;
}

int mychar_close(struct inode *pnode, struct file *pfile)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

    printk("mychar_close is called\n");
	if(pmydev->pasync_obj != NULL)
	{
		fasync_helper(-1,pfile,0,&pmydev->pasync_obj);  //则调用fasync_helper函数来取消异步通知
	}
    return 0;
}


ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{
	int ret = 0;
	int size = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	mutex_lock(&pmydev->lock);
	if(pmydev->curlen <= 0)
	{
		if(filp->f_flags & O_NONBLOCK)
		{//非阻塞
			mutex_unlock(&pmydev->lock);
			printk("O_NONBLOCK No Data Read\n");
			return -1;
		}
		else
		{//阻塞
			mutex_unlock(&pmydev->lock);
			ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
			if(ret)
			{
				printk("Wake up by signal\n");
				return -ERESTARTSYS;
			}
			mutex_lock(&pmydev->lock);
		}
	}

 	if(count > pmydev->curlen)
	{
		size = pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将内核空间中的数据复制到用户空间
	ret = copy_to_user(pbuf,pmydev->mydef_buf,size);
	if(ret)
	{
		mutex_unlock(&pmydev->lock);
		printk("copy_to_user failed\n");
		return -1;
	}
	//读完之后把后面的内容再拷贝过来，同时更新curlen
	memcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);
	pmydev->curlen = pmydev->curlen - size;
	mutex_unlock(&pmydev->lock);
	wake_up_interruptible(&pmydev->wq);

	return size;

}

ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{

	int size = 0;
	int ret  = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	mutex_lock(&pmydev->lock);
	if(pmydev->curlen >= BUF_LEN)
	{
		if(filp->f_flags & O_NONBLOCK)
		{
			mutex_unlock(&pmydev->lock);
			printk("O_NONBLOCK Can not write data\n");
			return -1;
		}
		else
		{
			mutex_unlock(&pmydev->lock);  //不能让write函数拿着资源睡眠，否则其他无法拿到资源了
			ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);
			if(ret)
			{
				printk("wake up by signal\n");
				return -ERESTARTSYS;
			}
			mutex_lock(&pmydev->lock);
		}
	}

	if(count > BUF_LEN - pmydev->curlen)
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将用户空间中的数据复制到内核空间中
	ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);
	if(ret)
	{
		mutex_unlock(&pmydev->lock);
		printk("copy_from_user failed\n");
		return -1;
	}
    //更新curlen
	pmydev->curlen = pmydev->curlen + size;

	mutex_unlock(&pmydev->lock);
	wake_up_interruptible(&pmydev->rq);

	//数据写成功发送可读信号（同样读函数也可以实现）
	if(pmydev->pasync_obj != NULL)
	{
		kill_fasync(&pmydev->pasync_obj,SIGIO,POLL_IN);
	}
	return size;
}

long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;


	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret,&maxlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			mutex_lock(&pmydev->lock);
			ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
			mutex_unlock(&pmydev->lock);
			if(ret)
			{
				printk("copy_to_user CURLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int mychar_poll(struct file *filp, poll_table *ptb)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;
	unsigned int mask = 0;

	//将等待队列头添加至poll_table表中
	poll_wait(filp, &pmydev->rq,ptb);
	poll_wait(filp, &pmydev->wq,ptb);
	
	mutex_lock(&pmydev->lock);
	if(pmydev->curlen > 0) //有数据可读
	{
		mask |= POLLIN | POLLRDNORM;
	}
	if(pmydev->curlen < BUF_LEN) //有空间可写
	{
		mask |= POLLOUT | POLLWRNORM;
	}
	mutex_unlock(&pmydev->lock);

	return mask;
	
	
}

//使用pmydev->pasync_obj作为异步通知对象进行注册
int mychar_fasync(int fd,struct file *filp,int mode)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	return fasync_helper(fd,filp,mode,&pmydev->pasync_obj);
}

//结构体初始化:部分变量赋值初始化
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = mychar_open,
    .release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
	.unlocked_ioctl = mychar_ioctl,
	.poll = mychar_poll,
	.fasync = mychar_fasync,
};

int mychar_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major, minor);

    /* 申请设备号 */
    ret = register_chrdev_region(devno, mychar_num, "mychar");
    if (ret) {
        ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
        if (ret) {
            printk("get devno failed\n");
            return -1;
        }
		major = MAJOR(devno); // 容易遗漏，注意
    }

    /* 给struct cdev对象指定操作函数集 */
    cdev_init(&gmydev.mydev, &myops);

    /* 将 struct cdev对象添加到内核对应的数据结构里 */
    gmydev.mydev.owner = THIS_MODULE;
    cdev_add(&gmydev.mydev, devno, 1);

	//初始化队列
	init_waitqueue_head(&(gmydev.rq));
	init_waitqueue_head(&(gmydev.wq));
	//初始化信号量
	mutex_init(&gmydev.lock);	

    return 0;
}

void __exit mychar_exit(void)
{
    dev_t devno = MKDEV(major, minor);

    cdev_del(&gmydev.mydev);

    unregister_chrdev_region(devno, mychar_num);
	

}

//表示支持GPL的开源协议
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

Makefile

ifeq ($(KERNELRELEASE),)

ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)


modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install

clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions

else
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.o
obj-m += openonce_atomic.o
obj-m += openonce_spinlock.o
obj-m += mychar_sema.o
obj-m += mychar_mutex.o
endif

 testmychar_signal.c（略）同1.1示例

编译，添加到内核模块，测试并发

补充：

生产者消费者问题是操作系统中的一个经典同步问题，用于描述多个线程之间的协作和资源竞争。该问题涉及到两种类型的线程：生产者和消费者。

生产者线程负责生成数据，并将其放入一个共享的缓冲区中。消费者线程从缓冲区中取出数据并进行处理。缓冲区有限，当缓冲区满时，生产者必须等待消费者取走数据；当缓冲区为空时，消费者必须等待生产者生成数据。

为了解决生产者消费者问题，可以使用以下机制：

  1. 互斥锁：用于确保在同一时间只有一个线程能够访问共享缓冲区。
  2. 条件变量：用于线程间的通信。当缓冲区满时，生产者线程将释放该条件变量，使消费者线程进入等待状态，直到缓冲区不再满；当缓冲区为空时，消费者线程将释放该条件变量，使生产者线程进入等待状态，直到缓冲区非空。
  3. 信号量：用于控制生产者和消费者线程的执行顺序和数量。可以使用两个计数信号量来表示缓冲区中的空槽和已占用槽的数量。

使用这些机制，可以编写一个并发程序来解决生产者消费者问题。在实现时需要注意避免线程死锁和饥饿的情况发生，确保线程能够正确地互相通信和协作。

以上是一般的解决方法，具体的实现细节可能会因操作系统和编程语言的不同而有所差异。

3 选择并发控制机制的原则

  • 不允许睡眠的上下文需要采用忙等待类（spin_lock)，可以睡眠的上下文可以采用阻塞类。在异常上下文中访问的竞争资源一定采用忙等待类。
  • 临界区操作较长的应用建议采用阻塞类，临界区很短的操作建议采用忙等待类。
  • 中断屏蔽仅在有与中断上下文共享资源时使用。
  • 共享资源仅是一个简单整型量时用原子变量

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Linux】python版本控制

【Linux】python版本控制

文章目录 1.查看目前python的版本2.添加软件源并更新3.选择你想要下载的版本4.警示&#xff1a;没必要设置默认版本误区千万千万不要覆盖python3软链接解决办法 5.安装pip换源 6.环境管理 网上有很多教程都是教导小白去官方下载之后编译安装。但是&#xff0c;小白连cmake是什么…
阅读更多...
【JavaEE】CAS

【JavaEE】CAS

作者主页&#xff1a;paper jie_博客 本文作者&#xff1a;大家好&#xff0c;我是paper jie&#xff0c;感谢你阅读本文&#xff0c;欢迎一建三连哦。 本文于《JavaEE》专栏&#xff0c;本专栏是针对于大学生&#xff0c;编程小白精心打造的。笔者用重金(时间和精力)打造&…
阅读更多...
使用xbindkeys设置鼠标侧键

使用xbindkeys设置鼠标侧键

1.安装如下包 sudo apt install xbindkeys xautomation 2.生成配置文件 xbindkeys --defaults > $HOME/.xbindkeysrc 3.确定侧键键号 在终端执行下面的代码&#xff1a; xev | grep button 此时会出现如下窗口&#xff0c;将鼠标指针移动到这个窗口上&#xff1a; 单…
阅读更多...
原生微信小程AR序实现模型动画播放只播放一次，且停留在最后一秒

原生微信小程AR序实现模型动画播放只播放一次，且停留在最后一秒

1.效果展示 0868d9b9f56517a9a07dfc180cddecb2 2.微信小程序AR是2023年初发布&#xff0c;还有很多问提&#xff08;比如glb模型不能直接播放最后一帧&#xff1b;AR识别不了金属、玻璃材质的模型等…有问题解决了的小伙伴记得告诉我一声&#xff09; 微信官方文档地址 3.代码…
阅读更多...
kotlin $ （字符串模版)的使用

kotlin $ （字符串模版)的使用

$ 在kotlin 中当做字符串模版使用&#xff0c;作用就是在字符串里面识别自己定义的字符 例如打印一个字符 这个时候编译就提示我们使用字符串模版的是个 $ 的作用就是识别字符串里面的i 字数有点少了&#xff0c;在写一个demo private fun String.appendArchive(): String …
阅读更多...
AI日报：扎克伯格瞄准AGI通用人工智能

AI日报：扎克伯格瞄准AGI通用人工智能

文章目录 Meta瞄准通用人工智能领域Meta的目标Meta的产品 FAIR移动和装载H100扎克伯格对人工智能竞争对手的真实动机持怀疑态度Meta抛弃了元宇宙吗&#xff1f; Meta瞄准通用人工智能领域 Meta首席执行官马克扎克伯格&#xff08;Mark Zuckerberg&#xff09;在一份可能改变全…
阅读更多...
QT+opencv源码编译

QT+opencv源码编译

时间记录&#xff1a;2024/1/20 一、版本介绍 QT5.12.7cmake3.22.0opencv4.5.4 二、编译步骤 &#xff08;1&#xff09;下载opencv源码&#xff0c;然后安装&#xff0c;opencv的安装即对源码的解压过程&#xff0c;解压后的文件目录如下 &#xff08;2&#xff09;openc…
阅读更多...
硬件---关于 埋孔、盲孔、通孔的介绍

硬件---关于 埋孔、盲孔、通孔的介绍

简介 埋孔、盲孔、通孔 都是应用于PCB不同板层之间的换层。 简单区分&#xff1a; 埋孔&#xff1a; 藏在里面&#xff0c;从上往下或者从下往上都看不见&#xff1b; 盲孔&#xff1a;从表面看有个孔&#xff0c;但是看不见底&#xff1b; 通孔&#xff1a;从表面看底是穿的…
阅读更多...
保姆级最新版Kali虚拟机安装和汉化中文教程

保姆级最新版Kali虚拟机安装和汉化中文教程

Kali虚拟机简介 Kali虚拟机是一款基于Debian的Linux发行版虚拟机操作系统&#xff0c;专为安全渗透测试和数字取证而设计。该虚拟机预装了许多渗透测试软件&#xff0c;包括Metasploit、BurpSuite、sqlmap、nmap以及Cobalt Strike等&#xff0c;这些工具都是为了进行网络安全测…
阅读更多...
第十回 朱贵水亭施号箭 林冲雪夜上梁山-FreeBSD/Linux 控制台基础操作

第十回 朱贵水亭施号箭 林冲雪夜上梁山-FreeBSD/Linux 控制台基础操作

林冲被众庄客捉住&#xff0c;吊在门楼下&#xff0c;正被打时&#xff0c;柴进来了&#xff0c;赶快把林冲救下来。原来这是柴进打猎用的小庄子&#xff0c; 林冲就把火烧草料场一事跟柴进详细的说了。柴进说兄弟真是命运多磨难啊。林冲住了几日&#xff0c;恐怕连累柴进&…
阅读更多...
基于 OpenVINO, yolov5 推理

基于 OpenVINO, yolov5 推理

OpenVINO 是英特尔开发的一款功能强大的深度学习工具包&#xff0c;可实现跨多个硬件平台的优化神经网络推理。在本文中&#xff0c;我们讨论了 OpenVINO 的特性和优势&#xff0c;以及它如何与领先的计算机视觉平台 Viso Suite 集成&#xff0c;以构建和交付可扩展的应用程序。…
阅读更多...
【项目搭建三】SpringBoot引入redis

【项目搭建三】SpringBoot引入redis

添加依赖 本文使用spring data redis访问和操作redis&#xff0c;pom文件中加入以下依赖&#xff1a; <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depende…
阅读更多...
按键检测知识

按键检测知识

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、pandas是什么&#xff1f;二、使用步骤 1.引入库2.读入数据总结 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 例如&#xff1a;…
阅读更多...
70.Redis缓存优化实践（基于分类树场景）

70.Redis缓存优化实践（基于分类树场景）

文章目录 前言第一次优化第二次优化第三次优化第四次优化第五次优化 前言 分类树查询功能&#xff0c;在各个业务系统中可以说随处可见&#xff0c;特别是在电商系统中。 而在实际工作中&#xff0c;这样一个分类树查询&#xff0c;我们都不断的改进了好几次。这是为什么呢&…
阅读更多...
成功解决「MySQL问题1」启动mysql时：发生系统错误5拒绝访问

成功解决「MySQL问题1」启动mysql时：发生系统错误5拒绝访问

我 | 在这里 &#x1f575;️ 读书 | 长沙 ⭐软件工程 ⭐ 本科 &#x1f3e0; 工作 | 广州 ⭐ Java 全栈开发&#xff08;软件工程师&#xff09; ✈️公众号 | 热爱技术的小郑 。文章底部有个人公众号二维码。回复 Java全套视频教程 或 前端全套视频教程 即可获取 300G 教程资…
阅读更多...
ctfshow反序列化(web254-web266)

ctfshow反序列化(web254-web266)

目录 web254 web255 web256 web257 web258 web259 web260 web261 web262 web263 web264 web265 web266 web254 源码 <?php/* # -*- coding: utf-8 -*- # Author: h1xa # Date: 2020-12-02 17:44:47 # Last Modified by: h1xa # Last Modified time: 2020…
阅读更多...
【机组】存储器、总线及堆栈寄存器实验的解密与实战

【机组】存储器、总线及堆栈寄存器实验的解密与实战

​&#x1f308;个人主页&#xff1a;Sarapines Programmer&#x1f525; 系列专栏&#xff1a;《机组 | 模块单元实验》⏰诗赋清音&#xff1a;云生高巅梦远游&#xff0c; 星光点缀碧海愁。 山川深邃情难晤&#xff0c; 剑气凌云志自修。 ​目录 &#x1f33a;一、 实验目的 …
阅读更多...
拿捏！相关性分析，一键出图！皮尔逊、斯皮尔曼、肯德尔、最大互信息系数（MIC）、滞后相关性分析，直接运行！独家可视化程序！

拿捏！相关性分析，一键出图！皮尔逊、斯皮尔曼、肯德尔、最大互信息系数（MIC）、滞后相关性分析，直接运行！独家可视化程序！

适用平台&#xff1a;Matlab2020及以上 相关性分析是一种统计方法&#xff0c;用于衡量两个或多个变量之间的关系程度。通过相关性分析&#xff0c;我们可以了解变量之间的相互关系、依赖性&#xff0c;以及它们是如何随着彼此的变化而变化的。相关性分析通常包括计算相关系数…
阅读更多...
第二百七十九回

第二百七十九回

文章目录 1. 概念介绍2. 思路与方法2.1 实现思路2.2 实现方法 3. 示例代码4. 内容总结 我们在上一章回中介绍了"如何播放视频"相关的内容&#xff0c;本章回中将介绍如何选择单个图片文件.闲话休提&#xff0c;让我们一起Talk Flutter吧。 1. 概念介绍 我们在前面章…
阅读更多...
人工智能原理实验2（2）——罗马尼亚问题（贪婪搜索、A*搜索、BFS、DFS）

人工智能原理实验2（2）——罗马尼亚问题（贪婪搜索、A*搜索、BFS、DFS）

&#x1f9e1;&#x1f9e1;实验内容&#x1f9e1;&#x1f9e1; 根据上图以Zerind为初始状态&#xff0c;Bucharest为目标状态实现搜索&#xff0c;分别以贪婪搜索&#xff08;只考虑直线距离&#xff09;和A算法求解最短路径。 按顺序列出贪婪算法探索的扩展节点和其估价函数…
阅读更多...
最新文章

Copyright @ 2022~2023