linux进程间通讯指南-打通IPC大门,高效沟通无阻


在现代操作系统中,进程就像独立的个体,有时需要相互合作、数据共享,这就要求进程间能够高效通信。本文将为你揭开Linux进程间通信(IPC)的神秘面纱,探讨各种IPC工具的运作原理,同步机制的重要性,以及如何规避潜在风险。我们将通过丰富的C++示例,让你融会贯通IPC实践。


一、IPC概述:进程间畅所欲言


所谓IPC(Inter-Process Communication),就是指允许进程之间传递数据或进行通信控制的机制。在Linux下,主要的IPC工具包括管道(Pipe)、FIFO、消息队列(Message Queue)、共享内存(Shared Memory)、信号(Signal)等。


IPC工具可以分为两大类:

  • 数据传输工具:如管道、消息队列等,用于在进程间传递数据。

在这里插入图片描述


  • 同步工具:信号量、文件锁等同步工具,则控制对共享资源的访问顺序,避免竞争条件。

    在这里插入图片描述


二、选择恰当的IPC工具


1、数据传输工具

从上面的分类中我们可以看到,IPC 工具有很多,而区分这些工具的关键因素就是数据读取和写入的形式。

比如说,一些
IPC 工具要求在写数据时将数据从用户内存传输至内核内存,读取数据时则将数据从内核内存输入到用户内存。

其中最典型的就是流 式
socket 和管道。


(1)、流 式
socket

流式
socket 数据必须从用户缓冲区写入至
TCP 连接的发送缓冲区中 ,读取数据时则从
TCP 连接的接收缓冲区进行读取。

流式socket通常指的是面向连接的TCP socket,数据的发送和接收通过socket描述符来进行。

以下是一个简单的示例,演示如何使用TCP socket进行数据的发送和接收:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>int main() {const int server_port = 8080;const char* server_ip = "127.0.0.1";int sock_fd;struct sockaddr_in server_addr;// 创建socketsock_fd = socket(AF_INET, SOCK_STREAM, 0);if (sock_fd < 0) {std::cerr << "Failed to create socket" << std::endl;return 1;}// 设置服务器地址memset(&server_addr, 0, sizeof(server_addr));server_addr.sin_family = AF_INET;server_addr.sin_port = htons(server_port);if (inet_pton(AF_INET, server_ip, &server_addr.sin_addr) <= 0) {std::cerr << "Invalid address" << std::endl;close(sock_fd);return 1;}// 连接到服务器if (connect(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {std::cerr << "Failed to connect to the server" << std::endl;close(sock_fd);return 1;}// 发送数据const char* message = "Hello, Server!";if (send(sock_fd, message, strlen(message), 0) < 0) {std::cerr << "Send failed" << std::endl;close(sock_fd);return 1;}std::cout << "Message sent" << std::endl;// 接收数据char buffer[1024] = {0};ssize_t bytes_received = recv(sock_fd, buffer, sizeof(buffer) - 1, 0);if (bytes_received < 0) {std::cerr << "Receive failed" << std::endl;close(sock_fd);return 1;}std::cout << "Message received: " << buffer << std::endl;// 关闭socketclose(sock_fd);return 0;
}

在这个示例中,我们首先创建了一个TCP socket,然后设置了服务器的地址和端口,并尝试连接到服务器。一旦连接成功,我们使用send函数将一个字符串消息发送到服务器,消息数据从用户缓冲区(在这个例子中是message字符串)写入到TCP连接的发送缓冲区中。


接收数据时,我们使用recv函数从TCP连接的接收缓冲区读取数据到用户缓冲区(buffer数组)。如果recv函数成功,它返回接收到的字节数,我们将其打印出来。


最后,我们使用close函数关闭socket。

请注意,这个示例是一个阻塞的socket操作,sendrecv函数在数据发送或接收完成之前会阻塞。在实际的网络编程中,你可能需要处理更多的错误情况,并可能需要使用非阻塞socket或信号驱动I/O等技术来提高程序的响应性和性能。


(2)、管道

在Linux中,管道(pipe)是一种进程间通信(IPC)机制,允许一个进程(生产者)与另一个进程(消费者)通过一个缓冲区交换数据。管道是单向的,数据只能在一个方向上流动,并且通常用于父子进程或者兄弟进程之间的通信。

在这里插入图片描述


以下是演示管道通信的基本流程:

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <cerrno>
#include <cstring>int main() {int pipefds[2];pid_t pid;const char *message = "Hello, this is the message going through the pipe!";char readbuffer[128];// 创建管道if (pipe(pipefds) == -1) {std::cerr << "Pipe failed: " << strerror(errno) << std::endl;return 1;}// 创建子进程pid = fork();if (pid == -1) {std::cerr << "Fork failed" << std::endl;close(pipefds[0]); // 读取端close(pipefds[1]); // 写入端return 1;}if (pid > 0) {// 父进程,关闭读取端,使用写入端close(pipefds[0]);// 写数据到管道if (write(pipefds[1], message, strlen(message)) == -1) {std::cerr << "Write to pipe failed: " << strerror(errno) << std::endl;}close(pipefds[1]); // 关闭写入端// 等待子进程结束wait(NULL);} else {// 子进程,关闭写入端,使用读取端close(pipefds[1]);// 从管道读取数据if (read(pipefds[0], readbuffer, sizeof(readbuffer)) == -1) {std::cerr << "Read from pipe failed: " << strerror(errno) << std::endl;}readbuffer[strcspn(readbuffer, "\n")] = 0; // 去除换行符std::cout << "Message received through pipe: " << readbuffer << std::endl;close(pipefds[0]); // 关闭读取端}return 0;
}

在这个示例中,我们首先使用pipe系统调用创建了一个管道,并获取了两个文件描述符:pipefds[0](用于读取)和pipefds[1](用于写入)。


然后,我们使用fork创建了一个子进程。

在父进程中,我们关闭了读取端(pipefds[0]),并通过写入端发送了一个字符串消息到管道。

在子进程中,我们关闭了写入端(pipefds[1]),并从读取端读取了管道中的数据。

请注意,管道的缓冲区大小通常是有限的,Linux中默认的管道缓冲区大小为65536字节。如果生产者写入的数据超过了缓冲区的大小,写入操作将会阻塞,直到消费者读取了足够的数据,释放了缓冲区空间。


此外,由于管道是单向的,所以通常需要两个管道来进行双向通信:一个用于从父进程到子进程的通信,另一个用于从子进程到父进程的通信。而且,管道是半双工的,意味着在任何给定时间,只能进行一个方向的通信。


(3)、FIFO


FIFO(也称为命名管道或具名管道)提供了一种在不相关的进程之间进行通信的方式,与管道类似,但具有文件系统中的名称。这意味着任何进程都可以通过FIFO的路径名来打开它,进行读写操作。

以下演示FIFO通信的基本流程:

#include <iostream>
#include <fcntl.h>    // 包含 open 函数
#include <unistd.h>   // 包含 read, write 函数
#include <sys/stat.h>// 包含 S_IRUSR, S_IWUSR, S_IRGRP, S_IWGRP, S_IROTH, S_IWOTH
#include <cstring>// 创建FIFO
bool create_fifo(const char* fifo_name) {// 使用mkfifo创建FIFOif (mkfifo(fifo_name, 0666) == -1) { // 0666 表示读写权限给所有用户std::cerr << "Failed to create FIFO: " << strerror(errno) << std::endl;return false;}return true;
}// 写入FIFO
bool write_fifo(const char* fifo_name, const char* message) {int fd = open(fifo_name, O_WRONLY);if (fd == -1) {std::cerr << "Failed to open FIFO for writing: " << strerror(errno) << std::endl;return false;}if (write(fd, message, strlen(message)) == -1) {std::cerr << "Failed to write to FIFO: " << strerror(errno) << std::endl;close(fd);return false;}close(fd);return true;
}// 从FIFO读取
bool read_fifo(const char* fifo_name) {int fd = open(fifo_name, O_RDONLY);if (fd == -1) {std::cerr << "Failed to open FIFO for reading: " << strerror(errno) << std::endl;return false;}char buffer[1024];ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);if (bytes_read == -1) {std::cerr << "Failed to read from FIFO: " << strerror(errno) << std::endl;close(fd);return false;}buffer[bytes_read] = '\0'; // 确保字符串以null结尾std::cout << "Message received from FIFO: " << buffer << std::endl;close(fd);return true;
}int main() {const char* fifo_name = "/tmp/my_fifo";// 创建FIFOif (!create_fifo(fifo_name)) {return 1;}// 写入FIFOif (!write_fifo(fifo_name, "Hello, this is the message going through the FIFO!")) {return 1;}// 读取FIFOif (!read_fifo(fifo_name)) {return 1;}// 可以选择删除FIFO// unlink(fifo_name);return 0;
}

在这个示例中,我们首先定义了三个函数:

  • create_fifo:创建一个FIFO。
  • write_fifo:向FIFO写入数据。
  • read_fifo:从FIFO读取数据。

main函数中,我们首先创建了一个FIFO,然后向其写入了一条消息,最后从FIFO中读取消息并打印出来。

请注意,FIFO是一个阻塞设备,如果打开FIFO进行读取但没有进程写入数据,读取操作将阻塞。同样,如果打开FIFO进行写入但没有进程读取数据,写入操作也将阻塞。为了处理这种情况,通常需要使用非阻塞打开或配合使用信号和多路复用技术(如selectpoll)。

此外,FIFO的权限可以通过mkfifo的第二个参数来设置,类似于文件的权限设置。在上面的示例中,我们使用了0666,这表示FIFO对所有用户都是可读可写的。在实际应用中,应根据需要设置适当的权限。


(4)、其他数据传输工具-消息队列和udp

消息队列和UDP(用户数据报协议)是两种不同的进程间通信(IPC)和网络通信机制。它们都通过将数据写入内核来进行操作,但是它们在数据传输的方式和特性上有所不同。

  • 消息队列

消息队列是UNIX系统提供的一种IPC机制,允许进程发送和接收消息。消息队列通过key来标识,进程可以通过这个key来发送和接收消息。


以下是消息队列的演示:

#include <iostream>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <cstring>// 消息结构体
struct msgbuf {long mtype;char mtext[256];
};int main() {key_t key = ftok("some_file", 'a');  // 创建唯一的keyif (key == -1) {perror("ftok");return 1;}int msgid = msgget(key, 0666 | IPC_CREAT);  // 创建消息队列if (msgid == -1) {perror("msgget");return 1;}// 初始化消息msgbuf msg;msg.mtype = 1;strcpy(msg.mtext, "Hello, this is a message in the queue!");// 发送消息if (msgsnd(msgid, &msg, sizeof(msg.mtext), 0) == -1) {perror("msgsnd");msgctl(msgid, IPC_RMID, NULL);return 1;}// 接收消息msgrcv(msgid, &msg, sizeof(msg.mtext), msg.mtype, 0);std::cout << "Received message: " << msg.mtext << std::endl;// 删除消息队列if (msgctl(msgid, IPC_RMID, NULL) == -1) {perror("msgctl");return 1;}return 0;
}

在上面的示例中,我们首先使用ftok函数创建一个唯一的key,然后使用msgget函数创建或获取一个消息队列。我们定义了一个msgbuf结构体来存储消息的类型和内容。然后,我们使用msgsnd函数发送消息,使用msgrcv函数接收消息。最后,我们使用msgctl函数删除消息队列。


  • UDP套接字

UDP是一种无连接的网络通信协议,它允许应用程序发送和接收数据报(datagrams)。UDP不保证数据报的顺序、完整性或可靠性,因此它通常用于那些可以容忍一定丢包率的应用,如视频会议或在线游戏。


以下代码演示UDP通信:

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>int main() {int sockfd;struct sockaddr_in server_addr, client_addr;const char *message = "Hello, this is a UDP datagram!";char buffer[1024];// 创建UDP socketsockfd = socket(AF_INET, SOCK_DGRAM, 0);if (sockfd < 0) {perror("socket");return 1;}// 设置服务器地址memset(&server_addr, 0, sizeof(server_addr));server_addr.sin_family = AF_INET;server_addr.sin_port = htons(8080);server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");// 发送数据if (sendto(sockfd, message, strlen(message), 0,(struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {perror("sendto");close(sockfd);return 1;}std::cout << "UDP datagram sent" << std::endl;// 接收数据socklen_t len = sizeof(client_addr);ssize_t bytes_received = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,(struct sockaddr*)&client_addr, &len);if (bytes_received < 0) {perror("recvfrom");close(sockfd);return 1;}buffer[bytes_received] = '\0'; // 确保字符串以null结尾std::cout << "UDP datagram received: " << buffer << std::endl;// 关闭socketclose(sockfd);return 0;
}

在这个示例中,我们首先使用socket函数创建了一个UDP socket。然后,我们设置了服务器的地址和端口,并使用sendto函数发送了一个数据报。我们使用recvfrom函数接收了数据报,并打印了接收到的数据。最后,我们关闭了socket。

请注意,UDP是面向数据报的,每次发送和接收操作都是独立的,没有顺序或连接的概念。因此,每次写入和读取都是完整的一条消息,不能使用字节流的方式进行写入。


2、共享内存

共享内存是一种高效的进程间通信(IPC)机制,它允许两个或多个进程共享一个给定的存储区。由于共享内存允许进程直接访问同一块内存,因此它比管道、消息队列或套接字等其他IPC机制具有更高的性能。但是,共享内存需要适当的同步机制来避免竞态条件和数据不一致的问题。


以下是一个简单的示例,演示了如何使用共享内存和信号量来实现进程间的同步:

#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <cstring>int main() {key_t key = ftok("some_file", 'a');if (key == -1) {perror("ftok");return 1;}// 创建共享内存段int shm_id = shmget(key, sizeof(int), IPC_CREAT | 0666);if (shm_id < 0) {perror("shmget");return 1;}// 附加共享内存int *shared_mem = (int *)shmat(shm_id, NULL, 0);if (shared_mem == (void *)-1) {perror("shmat");return 1;}// 创建信号量int sem_id = semget(key, 1, IPC_CREAT | 0666);if (sem_id < 0) {perror("semget");return 1;}// 设置信号量的值if (semctl(sem_id, 0, SETVAL, 1) == -1) { // 初始值设为1perror("semctl SETVAL");return 1;}// 写入共享内存的进程*shared_mem = 42; // 写入数据// 等待信号量struct sembuf p_op = {sem_id, 0, -1};semop(sem_id, &p_op, 1);// 执行其他任务...// 通知信号量struct sembuf v_op = {sem_id, 0, 1};semop(sem_id, &v_op, 1);// 从共享内存分离if (shmdt(shared_mem) == -1) {perror("shmdt");return 1;}// 删除共享内存和信号量if (shmctl(shm_id, IPC_RMID, NULL) == -1) {perror("shmctl IPC_RMID");return 1;}if (semctl(sem_id, 0, IPC_RMID) == -1) {perror("semctl IPC_RMID");return 1;}return 0;
}

在这个示例中,我们首先使用ftok函数创建一个唯一的key,然后使用shmget函数创建一个共享内存段。我们使用shmat函数将共享内存附加到当前进程的地址空间,并将其映射到一个int指针上。

接着,我们使用semget函数创建一个信号量集,并使用semctl函数将其初始值设置为1。我们定义了两个信号量操作:p_op用于等待(P操作),v_op用于通知(V操作)。

在写入共享内存之前,我们执行了P操作,这会等待信号量的值为正。写入完成后,我们执行了V操作,这会增加信号量的值,允许其他进程访问共享内存。

最后,我们使用shmdt函数从共享内存分离,使用shmctlsemctl函数分别删除共享内存段和信号量集。

请注意,这个示例仅演示了单个进程中共享内存和信号量的使用。在实际的多进程环境中,你需要创建多个进程,并在它们之间同步对共享内存的访问。通常,这是通过在父进程中创建共享内存和信号量,然后在子进程中附加共享内存和操作信号量来实现的。


三、同步机制:规避惊心动魄


1、信号量

信号量(Semaphore)是一种同步机制,用于控制多个进程或线程对共享资源的访问。本质上就是内核维护的一个整数,其值永远不会小于
0。如果 一个进程试图将信号量的值减少至小于
0,那么内核会阻塞该操作,直到信号量增长到允许执行该操作的程度。


通常我们会使用一个二元信号量,也就是信号量的值要么是
0,要么是
1。此时非常类似于
mutex,mutex 的状态要么是已上锁,要么是未上锁 。


在C++中,可以使用 POSIX 线程库(pthread)提供的信号量功能。以下是使用二元信号量(也称为互斥锁,mutex)的一个简单示例:

#include <iostream>
#include <pthread.h>
#include <semaphore.h>// 创建一个信号量对象
sem_t sem;// 线程函数,尝试对共享资源进行操作
void* thread_function(void* arg) {// 等待(P操作)信号量,直到信号量的值大于0sem_wait(&sem);// 临界区开始std::cout << "Thread " << std::this_thread::get_id()<< " is in the critical section." << std::endl;// ... 执行对共享资源的操作 ...// 临界区结束// 通知(V操作)信号量,增加其值sem_post(&sem);return nullptr;
}int main() {// 初始化信号量,设置其值为1sem_init(&sem, 0, 1);// 创建线程pthread_t t1, t2;pthread_create(&t1, NULL, thread_function, NULL);pthread_create(&t2, NULL, thread_function, NULL);// 等待线程结束pthread_join(t1, NULL);pthread_join(t2, NULL);// 销毁信号量sem_destroy(&sem);return 0;
}

在这个示例中,我们首先使用sem_init函数初始化了一个信号量sem,其初始值为1。然后创建了两个线程t1t2,它们都尝试执行thread_function函数。

thread_function函数中,我们首先调用sem_wait函数来执行P操作,这会阻塞线程直到信号量的值大于0。一旦信号量的值大于0,sem_wait函数会减少信号量的值,然后线程可以进入临界区。在临界区内,线程可以安全地访问共享资源。

当线程完成对共享资源的访问后,它会调用sem_post函数来执行V操作,这会增加信号量的值,允许其他等待的线程进入临界区。

最后,在main函数中,我们等待所有线程结束,然后使用sem_destroy函数销毁信号量。

请注意,这个示例演示了如何使用信号量来同步两个线程对共享资源的访问。在实际应用中,信号量可以用于更复杂的同步场景,包括跨进程同步。此外,使用信号量时需要小心,以避免死锁和其他同步问题。


2、文件锁

文件锁是一种用于进程间同步的机制,它通过锁定文件的特定部分来实现。在UNIX和类UNIX系统中,文件锁通常通过fcntl函数来管理。

文件锁分为两种类型:

  • 读锁(共享锁):允许多个进程读取文件,但不能写入。

  • 写锁(互斥锁):只允许一个进程写入文件,其他进程不能读取也不能写入。

文件锁是自动释放的,当进程终止或完成对文件的访问时,内核会自动移除锁。

以下是使用C++演示文件锁的基本流程:

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>int main() {const char* filename = "example.txt";// 创建或打开文件int fd = open(filename, O_RDWR | O_CREAT, 0666);if (fd == -1) {perror("open");return 1;}// 锁定文件struct flock lock;memset(&lock, 0, sizeof(lock));lock.l_type = F_WRLCK; // 请求写锁lock.l_whence = SEEK_SET;lock.l_start = 0;lock.l_len = 0; // 0表示锁定整个文件// 使用fcntl尝试锁定文件if (fcntl(fd, F_SETLKW, &lock) == -1) {perror("fcntl F_SETLKW");close(fd);return 1;}// 临界区开始:文件已被锁定,可以安全写入std::cout << "File is locked for writing." << std::endl;// 执行写操作...// write(fd, "data", 4);// 临界区结束:解锁文件lock.l_type = F_UNLCK; // 请求解锁if (fcntl(fd, F_SETLK, &lock) == -1) {perror("fcntl F_SETLK");}close(fd); // 关闭文件描述符return 0;
}

在上述代码中,我们首先使用open函数打开或创建一个文件,并获取文件描述符fd。然后,我们设置了struct flock结构体来定义锁的参数,包括锁的类型(读锁或写锁)、起始位置、长度等。


我们使用fcntl函数与F_SETLKW命令来请求锁。F_SETLKW命令会阻塞调用进程,直到锁被成功设置。一旦获得锁,我们就可以安全地执行文件的写入操作。

完成操作后,我们将锁的类型设置为F_UNLCK,再次使用fcntl函数与F_SETLK命令来释放锁。


请注意,文件锁的行为可能会受到操作系统和文件系统的影响。在某些系统中,文件锁可能不是强制性的,这意味着其他进程可能能够忽略这些锁。在使用文件锁时,务必要确保正确地请求和释放锁,以避免死锁或资源泄露。


3、信号 (Signal)


我们还可以利用信号(Signal)在进程间传递消息,比如父进程通过信号通知子进程其已退出。不过,信号应用于IPC的情况并不常见,主要有以下两方面原因:

  • 信号遵循可靠传递原则,不会排队,可能会丢失;
  • 信号携带的信息量有限,不太适合传输大量数据。

因此,信号更多被用作进程间的"小纸条",告知对方发生了某些事件,具体数据传输还需要借助其他IPC工具。


需要详细了解信号 相关知识的通讯,请查阅往期文章:

  • Linux信号大揭秘-从中断到控制进程,一步步掌握进程通信利器!
  • linux信号集与信号掩码-保护信号处理程序,确保进程正确运行
  • linux进程家族-管理子进程,确保进程族稳健运行

四、结语


总的来说,选择IPC工具时需要考虑通信双方、数据量、同步需求等多方面因素,合理权衡就能找到最佳选择。这个领域学习曲线平缓,但内功修炼到极致,却又别有一番天地。你是否已跃跃欲试,迫不及待想投身到IPC的海洋中?本文仅作了简单探讨,若想彻底掌握该领域的精髓,不妨持续关注我们的后续分享。


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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

手动安装Nvidia驱动和CUDA Toolkit

1、打开cuda-toolkit 网站 CUDA Toolkit Archive | NVIDIA Developer 根据自己需要选择CUDA Toolkit版本&#xff0c;这里选择12.0.0 2、点击链接跳转到下载页面&#xff0c;选择操作系统类型和安装包类型 3、下载CUDA Toolkit 安装包 4、执行下载命令 wget https://develo…

【C语言】学生管理系统:完整模拟与实现

&#x1f308;个人主页&#xff1a;是店小二呀 &#x1f308;C语言笔记专栏&#xff1a;C语言笔记 &#x1f308;C笔记专栏&#xff1a; C笔记 &#x1f308;喜欢的诗句:无人扶我青云志 我自踏雪至山巅 &#x1f525;引言 本篇文章为修改了在校期间实训报告&#xff0c;使用C…

停止一个正在运行的线程

暴力停止方法 stop 该方法是不安全的&#xff0c;已经过时的方法&#xff0c;在其方法描述上 This method is inherently unsafe&#xff0c;这个方法实际上是不安全的 package com.alibaba.fescar.core.protocol.test;public class TestThreadStop {public static void main(S…

基于STM32开发的智能水族箱管理系统

目录 引言环境准备智能水族箱管理系统基础代码实现&#xff1a;实现智能水族箱管理系统 4.1 温度传感器数据读取4.2 水泵与加热器控制4.3 水位传感器数据读取4.4 用户界面与显示应用场景&#xff1a;水族箱管理与优化问题解决方案与优化收尾与总结 1. 引言 智能水族箱管理系…

day51 动态规划 121. 买卖股票的最佳时机 122.买卖股票的最佳时机II

121. 买卖股票的最佳时机 动态规划 1.确定dp数组&#xff08;dp table&#xff09;以及下标的含义 dp[i][0] 表示第i天持有股票所得最多现金 &#xff0c;这里可能有同学疑惑&#xff0c;本题中只能买卖一次&#xff0c;持有股票之后哪还有现金呢&#xff1f; 其实一开始现…

我们正迈向万物互联

物联网&#xff08;Internet of Things&#xff0c;IoT&#xff09;是近年来信息技术领域最引人注目的创新之一。它通过将物理世界与数字世界紧密相连&#xff0c;为我们的日常生活、工业生产、城市管理等多个领域带来了前所未有的变革。本文将深入探讨物联网的基本概念、技术原…

Java 18 新功能概述

Java 18 在 2022 年 3 月 22 日正式发布&#xff0c;Java 18 不是一个长期支持版本。 包含多项新特性和改进&#xff0c;如文件系统链接、文本块、表达式求值API、ForkJoinPool优化、Optional新方法等。 亮点还包括预览特性&#xff1a;Record Pattern Matching for Switch和增…

C++ - 查找算法 和 其他 算法

目录 一. 查找算法&#xff1a; 1.顺序查找&#xff1a; 2.二分查找&#xff1a; 二. 其他算法&#xff1a; 1.遍历算法&#xff1a; 2.求和、求平均值等聚合算法。 a.求和算法&#xff1a; b.求平均值算法&#xff1a; 一. 查找算法&#xff1a; 1.顺序查找&#xff1…

Python深度学习基于Tensorflow(15)OCR验证码 文本检测与识别实例

文章目录 文本检测文本识别CTC层生成验证码并制作数据集建立模型模型推理 参考 文本检测 文本检测和目标检测类似&#xff0c;其不同之处在于文本目标具有序列特征&#xff0c;有连续性&#xff0c;可以通过结合 Faster R-CNN 和 LSTM 的方式进行文本检测&#xff0c;如 CTPN …

学习请求接口

axios的方法 方法一 方法二 方式三 方式四 ajax请求 fetch请求 学习一下

告别冗长代码:Java Lambda 表达式如何简化你的编程

在现代软件开发中&#xff0c;高效和简洁的代码变得越来越重要。Java作为一门成熟而广泛使用的编程语言&#xff0c;一直在不断进化&#xff0c;以满足开发者的需求。Java 8的推出标志着一次重要的飞跃&#xff0c;其中最引人注目的特性之一便是Lambda表达式。 Lambda表达式为J…

RK3588推理RetinaFace出现问题

RK3588推理RetinaFace出现问题 在RK3588上测试RockChip提供的RetinaFace模型时&#xff0c;出现下面的问题 $ python RetinaFace_pic.py done --> Init runtime environment I RKNN: [02:27:16.501] RKNN Runtime Information: librknnrt version: 1.5.2 (c6b7b351a2023…

Windows11下Docker使用记录(五)

目录 准备1. WSL安装cuda container toolkit2. win11 Docker Desktop 设置3. WSL创建docker container并连接cuda4. container安装miniconda&#xff08;可选&#xff09; Docker容器可以从底层虚拟化&#xff0c;使我们能够在 不降级 CUDA驱动程序的情况下使用 任何版本的CU…

音视频开发19 FFmpeg 视频解码- 将 h264 转化成 yuv

视频解码过程 视频解码过程如下图所示&#xff1a; ⼀般解出来的是420p FFmpeg流程 这里的流程是和音频的解码过程一样的&#xff0c;不同的只有在存储YUV数据的时候的形式 存储YUV 数据 如果知道YUV 数据的格式 前提&#xff1a;这里我们打开的h264文件&#xff0c;默认是YU…

储能逆变器测试负载箱是如何实现的

储能逆变器测试负载箱是专门用于模拟各种负载条件的设备&#xff0c;主要用于对储能逆变器进行性能测试和评估。它可以根据实际需求&#xff0c;模拟不同的负载类型、负载大小和负载变化率&#xff0c;从而为储能逆变器的设计和优化提供准确的数据支持。那么&#xff0c;储能逆…

【递归、搜索与回溯】搜索

搜索 1.计算布尔二叉树的值2.求根节点到叶节点数字之和3. 二叉树剪枝4.验证二叉搜索树5.二叉搜索树中第K小的元素6.二叉树的所有路径 点赞&#x1f44d;&#x1f44d;收藏&#x1f31f;&#x1f31f;关注&#x1f496;&#x1f496; 你的支持是对我最大的鼓励&#xff0c;我们一…

defineProps定义类型

1.props标注类型 原因&#xff1a;确保给组件传递的props是类型安全的 <script setup lang"ts"> //1.使用别名类型或者接口定义Props类型 type Props {name:stringage?:number } //2 使用defineProps注解类型 const props defineProps<Props>() <…

全年申报!2024年陕西省双软企业认定条件标准、申报好处费用

1.双软企业是什么? 答:双软认证并不是一个资质,而是"软件产品登记"和"软件企业认定"两个不同资质的统称.叫做"双软企业" 2.双软企业的优惠政策是什么? 答:(1)软件产品登记的优惠政策:软件产品增值税,从13%减按3%征收,实行即征即退; (2)软件…

2024Stable Diffusion WebUI详细使用指南

Stable Diffusion WebUI&#xff08;AUTOMATIC1111&#xff0c;简称A1111&#xff09;是一个为高级用户设计的图形用户界面&#xff08;GUI&#xff09;&#xff0c;它提供了丰富的功能和灵活性&#xff0c;以满足复杂和高级的图像生成需求。由于其强大的功能和社区的活跃参与&…

22 - 游戏玩法分析 IV(高频 SQL 50 题基础版)

22 - 游戏玩法分析 IV 考点&#xff1a; 聚合函数 # 日期相加 date_add(min(event_date),INTERVAL 1 DAY) select round(count(distinct player_id)/(select count(distinct player_id) from Activity),2) fraction fromActivity where-- 如果日期加一天的数据能在表中…