进程与线程（四）

进程与线程（四）

  • 基于System V IPC对象的进程间通信机制
  • SystemV IPC引入
  • 查看Linux系统中IPC工具的方式
    • 查看所有IPC工具
      • 命令：ipcs
    • 查看指定的IPC工具
    • key值获取方法：ftok()函数
  • 消息队列
    • 消息队列的特征：
    • 消息队列的操作
      • 打开或者创建消息队列
      • 添加消息
      • 读取消息
      • 控制消息队列（删除消息队列）
  • 共享内存
    • 共享内存的特征
    • 共享内存的操作
      • 打开或者创建共享内存
      • 映射共享内存到用户的私有空间
      • 取消映射
      • 删除共享内存
  • 信号量
    • 无名信号量
    • 有名信号量 （有名信号量的位置：/dev/shm/）
      • 创建有名信号量
      • 申请资源（p操作）
      • 释放资源（V操作）
      • 关闭有名信号量
      • 删除有名信号量

基于System V IPC对象的进程间通信机制

IPC对象和文件一样,必须先创建,每个IPC对象都有特定Key值,ID值,拥有者,权限和使用大小等，但其读写操作不能使用普通文件的read/write方式。

SystemV IPC引入

1、在传统的UNIX通信机制上进行了优化，形成一种更新的进程间通信机制
2、基于System V IPC相关的通信方式，全部使用ID来访问内存空间（数据存储的空
间）
2-1：ID的来源：创建或者打开内存空间时，内核给用户返回的
思考：毫无关系的两个进程如何得知同一片内存空间的ID？
—》空间谁创建的？
用户进程自己！（哪个用户来创建不限制）
办法：
创建者按照key值来创建并打开内核中的内存空间，最后拿到ID
使用者也按照同一个key值来打开内存空间，最后也能拿到同样的ID
2-2：Key值的来源：
key的来源1：key值是被创建出来的，通信双方只要使用同样的方式，即可获取到同一个Key
key的来源2：直接传入IPC_PRIVATE(死值)–》适合具有亲缘关系的进程间通信

查看Linux系统中IPC工具的方式

查看所有IPC工具

命令：ipcs

在这里插入图片描述

查看指定的IPC工具

查看消息队列：
ipcs -q
删除消息队列：
ipcrm -q msgid(ID值)
查看共享内存：
ipcs -m
删除共享内存：
ipcrm -m shmid
查看信号灯集：
ipcs -s
删除信号灯集：
ipcrm -s semid

在这里插入图片描述

key值获取方法：ftok()函数

在这里插入图片描述

消息队列

消息队列的特征：

1、消息队列是IPC对象的一种，实现两个进程间少量的收据传输,使用率最高
2、消息队列由消息队列ID来唯一标识
3、消息队列就是一个消息的列表（特殊的链式队列）。用户可以在消息队列中添加消息、读取消息等。
4、消息队列可以按照类型来发送/接收消息，先入先出(同一类型),不同类型的消息可以随机存取。
5、数据存放在内核当中

在这里插入图片描述
在这里插入图片描述

消息队列的操作

打开或者创建消息队列

在这里插入图片描述

添加消息

在这里插入图片描述

读取消息

在这里插入图片描述

控制消息队列（删除消息队列）

在这里插入图片描述
案例：创建消息队列收发消息
消息队列添加消息代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <errno.h>
#define N 100
//消息结构
typedef struct msgbuf
{
	long mtype; //消息类型
	char mtext[N]; //消息正文
}MSG;
int main(int argc, const char *argv[])
{
	//1，获取key值
	key_t key = ftok("./", 88);
	if(key < 0)
	{
		perror("ftok error");
		return -1;
	}
	printf("ftok ok! key = %d\n",key);
	//2，打开或者创建消息队列，获得ID值
	int msgid = msgget(key, IPC_CREAT | 0664);
	if(msgid < 0)
	{
		perror("msgget error");
		return -1;
	}
	printf("msgget ok! msgid = %d\n",msgid);
	//3，发送消息
	//构造消息
	//给消息类型赋值
	MSG m1;
	bzero(&m1, sizeof(m1));
	m1.mtype = 100;
	printf("请输入发送的第1个消息:\n");
	fgets(m1.mtext, sizeof(m1.mtext), stdin);
	MSG m2;
	bzero(&m2, sizeof(m2));
	//给消息类型赋值
	m2.mtype = 100;
	printf("请输入发送的第2个消息:\n");
	fgets(m2.mtext, sizeof(m2.mtext), stdin);
	MSG m3;
	bzero(&m3, sizeof(m3));
	//给消息类型赋值
	m3.mtype = 300;
	printf("请输入发送的第3个消息:\n");
	fgets(m3.mtext, sizeof(m3.mtext), stdin);
	//发送消息
	msgsnd(msgid, &m2, strlen(m2.mtext), 0);
	msgsnd(msgid, &m1, strlen(m1.mtext), 0);
	msgsnd(msgid, &m3, strlen(m3.mtext), 0);
	//删除消息队列
	//msgctl(msgid, IPC_RMID, NULL);
	return 0;
}

消息队列读取消息代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <strings.h>
#include <errno.h>
#define N 100
//消息结构
typedef struct msgbuf
{
	long mtype; //消息类型
	char mtext[N]; //消息正文
}MSG;
int main(int argc, const char *argv[])
{
	//1，获取key值
	key_t key = ftok("./", 88);
	if(key < 0)
	{
		perror("ftok error");
		return -1;
	}
	printf("ftok ok! key = %d\n", key);
	//2，打开或者创建消息队列，获得ID值
	int msgid = msgget(key, IPC_CREAT | 0664);
	if(msgid < 0)
	{
		perror("msgget error");
		return -1;
	}
	printf("msgget ok! msgid = %d\n", msgid);
	//3，读取消息
	MSG readMsg;
	bzero(&readMsg, sizeof(readMsg));
	msgrcv(msgid, &readMsg, sizeof(readMsg.mtext), 0, 0);//参数3为0 默认读取第
	一条消息
	//打印读取的消息
	printf("读取的队列中第一条消息为:%s\n", readMsg.mtext);
	//删除消息队列
	//msgctl(msgid, IPC_RMID, NULL);
	return 0;
}

在这里插入图片描述
注意：消息队列中的消息是读取一条则少一条，添加一条则多一条！

共享内存

共享内存的特征

1、共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存（映射之后的内存空间），而不需要任何数据的拷贝
2、为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间
3、进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。
4、由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等

命令管道和消息队列就存在数据拷贝的过程：如下图
在这里插入图片描述

而共享内存之所以高效的图解：如下：
在这里插入图片描述
注意：内核空间只有一份，所有进程的内核空间都是共享的。

共享内存的操作

打开或者创建共享内存

在这里插入图片描述

映射共享内存到用户的私有空间

在这里插入图片描述

取消映射

在这里插入图片描述

删除共享内存

在这里插入图片描述
案例：共享内存实现数据的交互
共享内存写端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
int main(int argc, const char *argv[])
{
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	printf("请输入写入到共享内存的信息:\n");
	fgets(p, 1024, stdin);
	//取消映射
	if(shmdt(p) < 0)
	{
		perror("shmdt error");
		return -1;
	}
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

共享内存读端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
int main(int argc, const char *argv[])
{
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	//读取共享内存中的消息
	printf("读取的结果为:");
	fputs(p, stdout);
	//取消映射
	if(shmdt(p) < 0)
		return -1;
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

在这里插入图片描述
思考：要是./r此时先运行，则会出现什么情况？
在这里插入图片描述
注意：要是想要让该两个进程之间形成一种同步关系，比如：先输入，再输出！如何实现？？？
—》进程间通信时，要同步可以使用有名信号量！！！
优化：使用有名信号量将上述共享内存的代码优化为同步（先输入， 再输出）
共享内存的写端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
#include <signal.h>
#include <stdlib.h>
sem_t *pFgets,*pFputs;
//信号处理函数
void func(int sig)
{
	//关闭有名信号量
	sem_close(pFgets);
	sem_close(pFputs);
	//删除有名信号量
	sem_unlink("SEM_FEGTS");
	sem_unlink("SEM_FPUTS");
	exit(0);
}
int main(int argc, const char *argv[])
{
	//注册一个信号和处理函数
	signal(SIGINT, func);
	//创建2个有名信号量
	pFgets = sem_open("SEM_FEGTS", O_RDWR | O_CREAT, 0664, 1);
	if(pFgets == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fgets ok!");
	pFputs = sem_open("SEM_FPUTS", O_RDWR | O_CREAT, 0664, 0);
	if(pFputs == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fputs ok!");
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	while(1)
	{
		//申请资源（P操作）
		sem_wait(pFgets);
		printf("请输入写入到共享内存的信息:\n");
		fgets(p, 1024, stdin);
		//释放资源（V操作）
		sem_post(pFputs);
	}
	//取消映射
	if(shmdt(p) < 0)
	{
		perror("shmdt error");
		return -1;
	}
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

共享内存的读端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
#include <signal.h>
#include <stdlib.h>
sem_t *pFgets,*pFputs;
void func(int sig)
{
	//关闭有名信号量
	sem_close(pFgets);
	sem_close(pFputs);
	//删除有名信号量
	sem_unlink("SEM_FEGTS");
	sem_unlink("SEM_FPUTS");
	exit(0);
}
int main(int argc, const char *argv[])
{
	//安装信号和处理函数
	signal(SIGINT, func);
	pFgets = sem_open("SEM_FEGTS", O_RDWR | O_CREAT, 0664, 1);
	if(pFgets == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fgets ok!");
	pFputs = sem_open("SEM_FPUTS", O_RDWR | O_CREAT, 0664, 0);
	if(pFputs == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fputs ok!");
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	while(1)
	{
		//申请资源（P操作）
		sem_wait(pFputs);
		//读取共享内存中的消息
		printf("读取的结果为:");
		fputs(p, stdout);
		//释放资源（V操作）
		sem_post(pFgets);
	}
	//取消映射
	if(shmdt(p) < 0)
		return -1;
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

在这里插入图片描述
当用户在键入输入ctrl c 之后，因为安装了信号处理函数，因此将有名信号量进行了删除，演示如下：
在这里插入图片描述

信号量

无名信号量

线程之间需要同步！

有名信号量 （有名信号量的位置：/dev/shm/）

进程之间需要同步！

创建有名信号量

#include <fcntl.h> /* For O_* constants /
#include <sys/stat.h> / For mode constants */
#include <semaphore.h>
sem_t *sem_open(const char *name, int oflag,
mode_t mode, unsigned int value);
参数1：有名信号量的名字（自己起）
参数2：打开方式：O_RDWR O_RDONLY O_WRONLY O_CREAT
参数3：有名信号量的权限：0664
参数4：给有名信号量的初始值（功能类似于无名信号量的初始化数值的函数sem_init（））
Link with -pthread. //编译要连接pthread库！！！
返回值：成功返回指向有名信号量的指针 失败返回SEM_FAILED

申请资源（p操作）

#include <semaphore.h>
int sem_wait(sem_t *sem);

释放资源（V操作）

#include <semaphore.h>
int sem_post(sem_t *sem);

关闭有名信号量

#include <semaphore.h>
int sem_close(sem_t *sem);

删除有名信号量

#include <semaphore.h>
int sem_unlink(const char *name);
参数：有名信号量的名字

案例：使用有名信号量实现进程1先打印hello 进程2再打印world
进程1代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
int main(int argc, const char *argv[])
{
	//创建2个有名信号量
	sem_t *pSem1 = sem_open("SEM_1", O_RDWR | O_CREAT, 0664, 1);
	if(SEM_FAILED == pSem1)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_1 ok!\n");
	sem_t *pSem2 = sem_open("SEM_2", O_RDWR | O_CREAT, 0664, 0);
	if(SEM_FAILED == pSem2)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_2 ok!\n");
	while(1)
	{
		//申请资源
		sem_wait(pSem1);
		printf("hello\n");
		sleep(1);
		//释放资源
		sem_post(pSem2);
	}
	//关闭有名信号量
	sem_close(pSem1);
	sem_close(pSem2);
	//删除有名信号量
	sem_unlink("SEM_1");
	sem_unlink("SEM_2");
	return 0;
}

进程2代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
int main(int argc, const char *argv[])
{
	//创建2个有名信号量
	sem_t *pSem1 = sem_open("SEM_1", O_RDWR | O_CREAT, 0664, 1);
	if(SEM_FAILED == pSem1)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_1 ok!\n");
	sem_t *pSem2 = sem_open("SEM_2", O_RDWR | O_CREAT, 0664, 0);
	if(SEM_FAILED == pSem2)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_2 ok!\n");
	while(1)
	{
		//申请资源
		sem_wait(pSem2);
		printf("world\n");
		sleep(1);
		//释放资源
		sem_post(pSem1);
	}
	//关闭有名信号量
	sem_close(pSem1);
	sem_close(pSem2);
	//删除有名信号量
	sem_unlink("SEM_1");
	sem_unlink("SEM_2");
	return 0;
}

在这里插入图片描述
使用有名管道实现循环聊天
思路：
1、创建两个有名管道，搭配两个子线程，双方对于其中某一个进行你发我收，另一个我发你收即可。
2、双方的收发各自使用线程处理函数解决

eg:clien1.c
#include <stdio.h>
//发送消息
void * send_func(void *arg)
{
	//write :fd, buf, strlen()/sizeof()
	mkfifo("com1.txt", 0664);
	int fw = open("com1.txt", O_WRONLY);
	while(1)
	{
		write(fw, buf, strlen(buf));
	}
}
//接收消息
void * recv_func(void *arg)
{
	mkfifo("com2.txt", 0664);
	int fr = open("com2.txt", O_RDONLY);
	while(1)
	{
		read(fr, buf, sizeof(buf));
	}
}
int main()
{
	//创建两个子进程
	//定义保存线程ID的变量
	pthread_t sendTHID;//保存发送子线程的ID号
	pthread_t recvTHID;//保存结束子线程的ID号
	pthread_create(&sendTHID, NULL, &send_func, NULL);
	pthread_create(&recvTHID, NULL, &recv_func, NULL);
	//线程分离 ---》当子线程结束时，自动释放其资源
	pthread_detach(sendTHID);
	pthread_detach(recvTHID);
	return 0;
}

eg:clien2.c
#include <stdio.h>
//发送消息
void * send_func(void *arg)
{
	//write :fd, buf, strlen()/sizeof()
	mkfifo("com2.txt", 0664);
	int fw = open("com2.txt", O_WRONLY);
	while(1)
	{
		write(fw, buf, strlen(buf));
	}
}
//接收消息
void * recv_func(void *arg)
{
	mkfifo("com1.txt", 0664);
	int fr = open("com1.txt", O_RDONLY);
	while(1)
	{
		read(fr, buf, sizeof(buf));
	}
}
int main()
{
	//创建两个子进程
	//定义保存线程ID的变量
	pthread_t sendTHID;//保存发送子线程的ID号
	pthread_t recvTHID;//保存结束子线程的ID号
	pthread_create(&sendTHID, NULL, &send_func, NULL);
	pthread_create(&recvTHID, NULL, &recv_func, NULL);
	//线程分离 ---》当子线程结束时，自动释放其资源
	pthread_detach(sendTHID);
	pthread_detach(recvTHID);
	return 0;
}

安装SIGCHLD信号，回收子进程的退出资源（僵尸进程的资源处理）

#include <stdio.h>
//使用信号处理函数让父进程回收子进程的退出资源
void reclamation_func(int signum)
{
	//回收资源
	/*
	//注意：while()循环只是起到可以进入处理函数内部时，一次性回收好几个子进程的退出资源
	思考：如果不加while()循环，则好几个子进程的退出资源需要好几次进入处理函数内部
	去回收
	while(waitpid(-1, NULL, WNOHANG) < 0)
	{
	;
	}
	*/
	int ret = waitpid(-1, NULL, WNOHANG);
	if(ret < 0)
	{
		perror("waitpid error");
	}
	else if(0 == waitpid)
	{
		printf("还未结束...\n");
	}
	else
	{
		printf("回收子进程OK 其PID = %d\n",ret);
	}
}
int main()
{
	//安装信号：绑定SIGCHLD信号 和一个回收子进程退出资源的信号处理函数
	signal(SIGCHLD, reclamation_func);
	pid_t pid = fork();
	if(pid < 0)
	exit(-1);
	else if (0 == pid)
	{
		//子进程
		printf("I am child Process!\n");
	}
	else
	{
		//父进程
		printf("I am Parent Process!\n");
		while(1);
	}
}

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

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

相关文章

数学建模 —— 插值与拟合（1）

数学建模 —— 插值与拟合（1）

一、matlab画图 1.1 plot&#xff08;二维图形&#xff09; plot(x) —— 缺省自变量绘图格式 plot(x,y) —— 基本格式&#xff0c;以y(x)的函数关系作出直角坐标图&#xff0c;如果y为nm的矩阵&#xff0c;则以x为自变量&#xff0c;作出m条曲线 plot(x1,y1,x2,y2,…,xn,…
阅读更多...
python深度学习入门-从零构建CNN和RNN

python深度学习入门-从零构建CNN和RNN

文章目录 第1章 基本概念1.1. 导数1.2. 链式法则1.3. 多输入函数的导数1.4. 多输入向量函数的导数1.5. 向量函数及其导数&#xff1a; 再进一步1.6. 包含两个二维矩阵数据的计算图 第2章 基本原理2.1. 监督学习概述2.2. 监督学习模型2.3. 线性回归2.3.1. 线性回归&#xff1a; …
阅读更多...
jupyter notebook更改位置

jupyter notebook更改位置

1.找到jupyer的配置文件 一般在c盘用户的.jupter文件夹下 2. 用记事本打开这个配置文件&#xff0c;定位到c.NotebookApp.notebook_dir /path_to_your_directory 替换你的位置 3.找到jupyer图标的位置&#xff0c;打开属性 添加要存放的位置在目标文件的末尾&#xff0c;重新…
阅读更多...
童梦奇缘，味你而来 —— 蒙自源六一儿童节特别活动

童梦奇缘，味你而来 —— 蒙自源六一儿童节特别活动

在六月的暖阳下&#xff0c;孩子们的欢笑声如同最美妙的乐章&#xff0c;奏响了夏日的序曲。在这个充满童真与梦想的季节&#xff0c;蒙自源精心策划了一场别开生面的六一儿童节特别活动&#xff0c;邀请每一位小朋友和大朋友&#xff0c;一同踏上一段奇妙的味蕾之旅。 从5月25…
阅读更多...
数据库(16)——DQL执行顺序

数据库(16)——DQL执行顺序

DQL的执行顺序 这是DQL的编写顺序。 而实际的执行顺序为
阅读更多...
企业级win10电脑下同时存在Python3.11.7Python3.6.6，其中Python3.6.6是后装的【过程与踩坑复盘】

企业级win10电脑下同时存在Python3.11.7Python3.6.6，其中Python3.6.6是后装的【过程与踩坑复盘】

背景&#xff1a; 需要迁移原始服务器的上的Python3.6.6Flask项目到一个新服务器上&#xff0c; 新服务器上本身存在一个Python3.11.7, 所以这涉及到了一个电脑需要装多个Python版本的问题 过程&#xff1a; 1-确定新电脑版本【比如是32还是64位】 前面开发人员存留了两个…
阅读更多...
读人工智能时代与人类未来笔记19_读后总结与感想兼导读

读人工智能时代与人类未来笔记19_读后总结与感想兼导读

1. 基本信息 人工智能时代与人类未来 (美)亨利基辛格,(美)埃里克施密特,(美)丹尼尔胡滕洛赫尔 著 中信出版社,2023年6月出版 1.1. 读薄率 书籍总字数145千字&#xff0c;笔记总字数39934字。 读薄率39934145000≈27.5% 1.2. 读厚方向 千脑智能 脑机穿越 未来呼啸而来 …
阅读更多...
golang的http客户端封装

golang的http客户端封装

简介 net/http 是 Go 语言标准库的一部分&#xff0c;它提供了创建 HTTP 客户端和服务器的能力。这个包通过简化与 HTTP 协议的交互&#xff0c;让开发者能够方便地构建 HTTP 请求和响应&#xff0c;以及处理路由等任务。 本文以 net/http 包作为底层&#xff0c;封装一个包含…
阅读更多...
解决VIvado编程中遇到的bug 5

解决VIvado编程中遇到的bug 5

解决VIvado编程中遇到的bug 5 语言 &#xff1a;Verilg HDL EDA工具&#xff1a; Vivado、quartus2 、modelsim 解决VIvado编程中遇到的bug 5一、引言二、问题、分析及解决方法1. vivado编译时报错&#xff08;1&#xff09;错误&#xff08;2&#xff09;分析&#xff08;3&am…
阅读更多...
HTML标签（超链接、锚、表格、表单）

HTML标签（超链接、锚、表格、表单）

HTML的标签2 超链接标签&#xff1a;锚链接&#xff1a;表格标签&#xff1a;表单&#xff1a;输入输出&#xff1a; 超链接标签&#xff1a; 超链接标签&#xff1a;a ​ 属性&#xff1a; ​ href - 链接地址 ​ target - 跳转目标&#xff08;_self在当前卡…
阅读更多...
基于单片机的病床呼叫系统设计研究

基于单片机的病床呼叫系统设计研究

摘要&#xff1a;随着无线技术的快速发展&#xff0c;无线应用技术已经运用到人们生产生活中的多个领域&#xff0c;运用无线技术来设计病床呼叫系统能够实现无线信号的远距离传输&#xff0c;减少材料耗费&#xff0c;使医患之间的沟通更加便捷&#xff0c;该系统运用单片机作…
阅读更多...
VSCode界面Outline只显示类名和函数名，隐藏变量名

VSCode界面Outline只显示类名和函数名，隐藏变量名

参考链接 https://blog.csdn.net/Zjhao666/article/details/120523879https://blog.csdn.net/Williamcsj/article/details/122401996 VSCode中界面左下角的Outline能够方便快速跳转到文件的某个类或函数&#xff0c;但默认同时显示变量&#xff0c;导致找某个函数时很不方便。…
阅读更多...
【传知代码】多视图3D目标检测位置嵌入变换（论文复现）

【传知代码】多视图3D目标检测位置嵌入变换（论文复现）

前言&#xff1a;三维目标检测技术正逐渐成为计算机视觉领域的重要研究方向。特别是在自动驾驶、增强现实&#xff08;AR&#xff09;、虚拟现实&#xff08;VR&#xff09;以及机器人导航等应用中&#xff0c;对三维空间内目标的精准检测与定位显得尤为重要。然而&#xff0c;…
阅读更多...
virtualbox虚拟机、centos7安装增强工具

virtualbox虚拟机、centos7安装增强工具

文章目录 1. virtualBox语言设置2. 设置终端启动快捷键3. 添加virtualbox 增强工具4. 设置共享文件夹 1. virtualBox语言设置 virtualbox -> file -> perferences -> language ->选择对应的语言 -> OK virtualbox -> 管理 -> 全局设定 -> 语言 -> …
阅读更多...
点赋科技：建设智能饮品高地，打造数字化产业先锋

点赋科技：建设智能饮品高地，打造数字化产业先锋

在当今数字化时代的浪潮中&#xff0c;点赋科技以其敏锐的洞察力和卓越的创新能力&#xff0c;致力于建设智能饮品高地&#xff0c;打造数字化产业先锋。 点赋深知智能饮品机对于推动社会进步和满足人们日益增长的需求的重要性。因此&#xff0c;他们投入大量资源和精力&#x…
阅读更多...
[AI Google] 三种新方法利用 Gemini 提高 Google Workspace 的生产力

[AI Google] 三种新方法利用 Gemini 提高 Google Workspace 的生产力

Workspace 侧边栏中的 Gemini 现在将使用 Gemini 1.5 Pro&#xff0c;新的 Gemini for Workspace 功能即将登陆 Gmail 移动应用&#xff0c;等等。 Gemini for Google Workspace 帮助个人和企业更好地利用 Google 应用——从在 Gmail 中撰写邮件到在 Sheets 中组织项目计划。过…
阅读更多...
echarts学习: 图表自适应

echarts学习: 图表自适应

1.实现基本功能 我最近在研究如何封装echarts组件&#xff0c;几乎每个相关的文章都会给组件添加图表自适应的功能。其原理也很简单&#xff0c;就是通过侦听window的resize事件&#xff0c;当事件触发时就调用chartInstance.resize方法重置图表尺寸。 基本代码如下: // 重置…
阅读更多...
如何快速上手Python，成为一名数据分析师

如何快速上手Python，成为一名数据分析师

目录 写在前面 推荐图书 推荐理由 粉丝福利 写在最后 写在前面 520快乐&#xff01;喜欢Python的小伙伴有福啦&#xff0c;本期博主给大家推荐一本入门Python的热门书籍&#xff0c;快来看看吧~ 推荐图书 《Python数据分析快速上手》(王靖&#xff0c;商艳红&#xff0…
阅读更多...
基础数学内容重构（后缀0个数）

基础数学内容重构（后缀0个数）

今天也是参加了一下宁波大学的校赛&#xff0c;其中有一道题是求后缀0的个数&#xff0c;题意是让我们求一下式子的后缀0个数&#xff1a; 看上去比较复杂&#xff0c;但是通过化简我们可以知道以上式子就是求&#xff08;n 1&#xff09;&#xff01;&#xff0c;这里化简的过…
阅读更多...
【学习笔记】Vue3（Ⅰ）

【学习笔记】Vue3（Ⅰ）

Vue3（Ⅰ） 1、 概述 1.1、概述 1.2、使用 Vite 创建工程 1.2.1 Vite 介绍 1.2.2 创建工程 1.3、项目文件结构2、 基础 2.1、setup 2.1.1 初识 setup 2.1.2 setup 的返回值 2.1.3 setup 的触发时机…
阅读更多...
最新文章

Copyright @ 2022~2023