Linux系统编程-进程间通信（IPC）常用方式详解

news2024/9/22 7:29:03

        进程间通信（IPC，Inter-Process Communication）是指在操作系统中，不同进程之间进行数据交换和信息传递的机制。这种通信允许正在运行的多个进程能够相互协作、共享数据或者进行同步操作，以实现更复杂的任务和功能。Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信。

1.管道-pipe

管道（Pipe）是一种进程间通信（IPC）机制，允许具有亲缘关系的进程之间进行单向通信。它是Unix和类Unix操作系统中常见的IPC方式之一，通常用于在父子进程或者兄弟进程之间传递数据。

概念：

管道是一种特殊的文件描述符，它连接了两个进程，其中一个进程的输出作为另一个进程的输入。管道是单向的，即数据只能在一个方向上流动。通常有两种类型的管道：

  • 匿名管道：存在于具有亲缘关系的进程之间，通常用于父子进程之间或者通过fork()系统调用创建的进程间通信。

  • 命名管道（FIFO）：是一种特殊的文件系统对象，允许不相关的进程通过文件路径来进行通信。

原理：

管道基于操作系统提供的内核缓冲区进行数据传输。在Unix系统中，管道可以通过pipe()系统调用创建。pipe()系统调用会创建一个管道，并返回两个文件描述符：

  • 第一个文件描述符用于管道的写入端（写入数据的进程将数据发送到这一端）。
  • 第二个文件描述符用于管道的读取端（读取数据的进程从这一端接收数据）。

管道的工作原理可以简单描述为：

  1. 进程A调用pipe()系统调用创建管道，得到两个文件描述符fd[0]（读取端）和fd[1]（写入端）。
  2. 进程A通过fork()创建进程B，此时进程A和进程B都能够访问这两个文件描述符。
  3. 进程A可以通过fd[1]写入数据到管道，而进程B可以通过fd[0]从管道中读取数据。

数据在管道中是先进先出（FIFO）的顺序进行传递，当进程向管道写入数据时，数据会被存储在内核缓冲区中，等待被读取进程读取。

局限性：

  • 单向通信：管道只支持单向数据传输，即数据只能从一个方向流动。

  • 具有亲缘关系的进程：匿名管道只能用于具有亲缘关系的进程之间，通常是父子进程或者通过fork()创建的进程。

  • 容量有限：管道的容量是有限的，通常在几千字节到几兆字节之间，这取决于操作系统的具体实现。

  • 无法进行双向通信：如果需要双向通信，通常需要创建两个管道，一个用于从父进程到子进程，另一个用于从子进程到父进程。

  • 阻塞问题：管道的读取端和写入端在一些情况下可能会发生阻塞，特别是当管道为空或者已满时。

1.1pipe()

管道（Pipe）通过pipe()系统调用来创建。pipe()函数可以在进程间创建一个管道，这个管道具有两个文件描述符：一个用于读取端，一个用于写入端。这种方式可以实现具有亲缘关系的进程之间的单向通信。

函数原型：
#include <unistd.h>

int pipe(int pipefd[2]);
参数：pipefd是一个整型数组，长度为2，用于存储管道的两个文件描述符。
pipefd[0]：用于读取管道数据的文件描述符（读取端）。
pipefd[1]：用于写入管道数据的文件描述符（写入端）。
返回值：成功时返回0，失败时返回-1，并设置errno以指示错误类型。

示例代码：父子进程使用管道pipe通信

一个进程在由pipe()创建管道后，一般再fork一个子进程，然后通过管道实现父子进程间的通信（因此也不难推出，只要两个进程中存在血缘关系，这里的血缘关系指的是具有共同的祖先，都可以采用管道方式来进行通信）。父子进程间具有相同的文件描述符，且指向同一个管道pipe，其他没有关系的进程不能获得pipe（）产生的两个文件描述符，也就不能利用同一个管道进行通信。

步骤：

第一步：父进程创建管道：

第二步：父进程fork出子进程：

第三步：父进程关闭fd[0]，子进程关闭fd[1]

创建步骤总结：

  • 父进程调用pipe函数创建管道，得到两个文件描述符fd[0]和fd[1]，分别指向管道的读端和写端。
  • 父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一管。
  • 父进程关闭管道读端，子进程关闭管道写端。父进程可以向管道中写入数据，子进程将管道中的数据读出，这样就实现了父子进程间通信。
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>

#define BUFFER_SIZE 25

int main() {
    int pipefd[2];
    pid_t pid;
    char parent_message[BUFFER_SIZE] = "Hello, child!";
    char child_message[BUFFER_SIZE];

    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    pid = fork();

    if (pid < 0) {  // 错误处理
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid > 0) {  // 父进程
        close(pipefd[0]);  // 关闭父进程的读取端

        // 向管道写入数据
        write(pipefd[1], parent_message, strlen(parent_message) + 1);
        printf("Parent wrote: %s\n", parent_message);

        close(pipefd[1]);  // 关闭写入端

        // 等待子进程结束
        wait(NULL);
    } else {  // 子进程
        close(pipefd[1]);  // 关闭子进程的写入端

        // 从管道读取数据
        read(pipefd[0], child_message, BUFFER_SIZE);
        printf("Child read: %s\n", child_message);

        close(pipefd[0]);  // 关闭读取端
    }

    return 0;
}

示例代码：使用管道（pipe）实现两个进程间的全双工通信（即双向通信）

步骤：

  1. 创建两个管道：一个用于进程A到进程B的数据传输，另一个用于进程B到进程A的数据传输。
  2. 创建子进程：使用 fork() 创建子进程。
  3. 关闭不需要的管道端：根据通信方向关闭不需要的管道端。
  4. 进行读写操作：进程A和进程B分别通过各自的管道端进行读写操作。
  5. 关闭管道：通信结束后关闭管道。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

#define BUFFER_SIZE 1024

int main() {
    int pipeAtoB[2]; // 管道A到B
    int pipeBtoA[2]; // 管道B到A
    pid_t pid;
    char buffer[BUFFER_SIZE];

    // 创建管道
    if (pipe(pipeAtoB) == -1 || pipe(pipeBtoA) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) { // 子进程B
        close(pipeAtoB[1]); // 关闭子进程B中A到B的写端
        close(pipeBtoA[0]); // 关闭子进程B中B到A的读端

        // 从父进程A读取数据
        read(pipeAtoB[0], buffer, BUFFER_SIZE);
        printf("Child process received: %s\n", buffer);

        // 向父进程A发送数据
        char *message = "Hello from Child Process!";
        write(pipeBtoA[1], message, strlen(message) + 1);

        close(pipeAtoB[0]); // 关闭子进程B中A到B的读端
        close(pipeBtoA[1]); // 关闭子进程B中B到A的写端
        exit(EXIT_SUCCESS);
    } else { // 父进程A
        close(pipeAtoB[0]); // 关闭父进程A中A到B的读端
        close(pipeBtoA[1]); // 关闭父进程A中B到A的写端

        // 向子进程B发送数据
        char *message = "Hello from Parent Process!";
        write(pipeAtoB[1], message, strlen(message) + 1);

        // 从子进程B读取数据
        read(pipeBtoA[0], buffer, BUFFER_SIZE);
        printf("Parent process received: %s\n", buffer);

        close(pipeAtoB[1]); // 关闭父进程A中A到B的写端
        close(pipeBtoA[0]); // 关闭父进程A中B到A的读端

        // 等待子进程结束
        wait(NULL);
    }

    return 0;
}

注意事项：

  • 管道关闭：每个进程关闭自己不需要的管道端，以防止数据流动错误和资源浪费。
  • 同步问题：此示例程序使用简单的读写顺序进行同步。如果需要更复杂的同步机制，可能需要额外的同步方法（如信号量、条件变量等）。
  • 缓冲区大小：确保缓冲区大小足够大以容纳传递的数据。

2.命名管道-FIFO

        FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间通信。但通过FIFO，不相关的进程也能交换数据。

        FIFO是Linux基础文件类型中的一种（文件类型为p，可通过ls -l查看文件类型）。但FIFO文件在磁盘上没有数据块，文件大小为0，仅仅用来标识内核中一条通道。进程可以打开这个文件进行read/write，实际上是在读写内核缓冲区，这样就实现了进程间通信。

2.1mkfifo()

函数原型：
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
参数：
pathname：指定要创建的命名管道的路径名。
mode：指定创建的文件权限模式，类似于chmod()函数中的权限设置。通常使用S_IRUSR、S_IWUSR等宏定义来设置。
返回值：
成功：返回0。
失败：返回-1，并设置适当的错误码。

示例代码：使用命名管道fifo完成两个进程的通信

写入数据

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

#define FIFO_PATH "./myfifo"
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    const char *message = "Hello from Process 1!";

    // 创建命名管道
    if (mkfifo(FIFO_PATH, 0666) == -1) {
        perror("mkfifo");
        exit(EXIT_FAILURE);
    }

    printf("Named pipe created at %s\n", FIFO_PATH);

    // 打开命名管道以写入数据
    fd = open(FIFO_PATH, O_WRONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 写入数据到命名管道
    strncpy(buffer, message, BUFFER_SIZE);
    if (write(fd, buffer, strlen(buffer) + 1) == -1) {
        perror("write");
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("Process 1 sent message: %s\n", message);

    // 关闭管道
    close(fd);

    // 删除命名管道
    if (unlink(FIFO_PATH) == -1) {
        perror("unlink");
        exit(EXIT_FAILURE);
    }

    printf("Named pipe deleted.\n");

    return 0;
}

读取数据：

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

#define FIFO_PATH "./myfifo"
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char buffer[BUFFER_SIZE];

    // 打开命名管道以读取数据
    fd = open(FIFO_PATH, O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 从命名管道读取数据
    if (read(fd, buffer, BUFFER_SIZE) == -1) {
        perror("read");
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("Process 2 received message: %s\n", buffer);

    // 关闭管道
    close(fd);

    return 0;
}

通常情况下，先启动写入数据的进程，再启动读取数据的进程。如果读取进程先启动，可能会导致它在尝试打开命名管道时出现阻塞，直到写入进程也启动并打开管道为止。

  • FIFO的阻塞特性：

    • FIFO 是一种特殊的文件系统对象，它具有阻塞的特性。当一个进程尝试打开一个写端的 FIFO 进行写入操作时，如果没有进程打开对应的读端，写入进程可能会被阻塞，直到有进程打开了读端。

  • 进程启动顺序的影响：

    • 如果先启动了写入数据的进程，并且该进程尝试打开一个 FIFO 进行写入操作，但此时没有其他进程打开同一个 FIFO 的读端，写入进程会阻塞等待。
    • 只有当读取数据的进程启动并打开了相同的 FIFO 读端时，写入进程才能继续执行，向 FIFO 写入数据。

示例代码：使用命名管道（FIFO）实现两个非血缘关系的进程间全双工通信

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

#define FIFO_AtoB "fifo_a_to_b"
#define FIFO_BtoA "fifo_b_to_a"
#define BUFFER_SIZE 1024

int main() {
    int fd_write, fd_read;
    char buffer[BUFFER_SIZE];
    int count = 0;

    // 创建命名管道A到B
    if (mkfifo(FIFO_AtoB, 0666) == -1) {
        perror("mkfifo A to B");
        exit(EXIT_FAILURE);
    }

    // 创建命名管道B到A
    if (mkfifo(FIFO_BtoA, 0666) == -1) {
        perror("mkfifo B to A");
        exit(EXIT_FAILURE);
    }

    printf("Named pipes created successfully.\n");

    // 打开命名管道A到B以写入数据
    fd_write = open(FIFO_AtoB, O_WRONLY);
    if (fd_write == -1) {
        perror("open write");
        exit(EXIT_FAILURE);
    }

    // 打开命名管道B到A以读取数据
    fd_read = open(FIFO_BtoA, O_RDONLY);
    if (fd_read == -1) {
        perror("open read");
        exit(EXIT_FAILURE);
    }

    while (1) {
        // 读取用户输入
        printf("Process A, enter message: ");
        fgets(buffer, BUFFER_SIZE, stdin);

        // 向进程B发送数据
        write(fd_write, buffer, strlen(buffer) + 1);
        printf("Process A sent: %s\n", buffer);

        // 检查终止条件
        if (strcmp(buffer, "exit\n") == 0) {
            break;
        }

        // 从进程B读取数据
        read(fd_read, buffer, BUFFER_SIZE);
        printf("Process A received: %s\n", buffer);

        // 检查终止条件
        if (strcmp(buffer, "exit\n") == 0) {
            break;
        }

        count++;
    }

    // 关闭命名管道
    close(fd_write);
    close(fd_read);

    // 删除命名管道
    unlink(FIFO_AtoB);
    unlink(FIFO_BtoA);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define FIFO_AtoB "fifo_a_to_b"
#define FIFO_BtoA "fifo_b_to_a"
#define BUFFER_SIZE 1024

int main() {
    int fd_write, fd_read;
    char buffer[BUFFER_SIZE];
    int count = 0;

    // 打开命名管道A到B以读取数据
    while ((fd_read = open(FIFO_AtoB, O_RDONLY)) == -1) {
        perror("open read");
        sleep(1); // 等待管道创建
    }

    // 打开命名管道B到A以写入数据
    while ((fd_write = open(FIFO_BtoA, O_WRONLY)) == -1) {
        perror("open write");
        sleep(1); // 等待管道创建
    }

    while (1) {
        // 从进程A读取数据
        read(fd_read, buffer, BUFFER_SIZE);
        printf("Process B received: %s\n", buffer);

        // 检查终止条件
        if (strcmp(buffer, "exit\n") == 0) {
            break;
        }

        // 读取用户输入
        printf("Process B, enter message: ");
        fgets(buffer, BUFFER_SIZE, stdin);

        // 向进程A发送数据
        write(fd_write, buffer, strlen(buffer) + 1);
        printf("Process B sent: %s\n", buffer);

        // 检查终止条件
        if (strcmp(buffer, "exit\n") == 0) {
            break;
        }

        count++;
    }

    // 关闭命名管道
    close(fd_read);
    close(fd_write);

    return 0;
}

3.内存映射区

内存映射IO详解

存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。从缓冲区中取数据，就相当于读文件中的相应字节；将数据写入缓冲区，则会将数据写入文件。这样，就可在不使用read和write函数的情况下，使用地址（指针）完成I/O操作。使用存储映射这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

示例代码：使用mmap完成父子进程间通信

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>
#include <sys/wait.h>

#define FILE_PATH "mapped_file.txt"
#define FILE_SIZE 4096

int main() {
    int fd;
    char *mapped_memory;

    // 创建或打开文件，并设置文件大小
    fd = open(FILE_PATH, O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    if (ftruncate(fd, FILE_SIZE) == -1) {
        perror("ftruncate");
        exit(EXIT_FAILURE);
    }

    // 创建存储映射区
    mapped_memory = mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mapped_memory == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    // 关闭文件描述符
    close(fd);

    // 创建子进程
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // 子进程
        printf("Child process reading from memory-mapped file: %s\n", mapped_memory);
        // 修改映射区中的数据
        strcpy(mapped_memory, "Hello from Child Process!");
        exit(EXIT_SUCCESS);
    } else {
        // 父进程
        // 写入数据到映射区
        strcpy(mapped_memory, "Hello from Parent Process!");

        // 等待子进程完成
        wait(NULL);

        // 再次读取子进程修改后的数据
        printf("Parent process reading from memory-mapped file: %s\n", mapped_memory);

        // 释放存储映射区
        if (munmap(mapped_memory, FILE_SIZE) == -1) {
            perror("munmap");
            exit(EXIT_FAILURE);
        }
    }

    return 0;
}

示例代码：使用mmap完成没有血缘关系的进程间通

写进程

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>

#define FILE_PATH "shared_file.txt"
#define FILE_SIZE 4096

int main() {
    int fd;
    char *mapped_memory;

    // 打开文件，创建并设置大小
    fd = open(FILE_PATH, O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    if (ftruncate(fd, FILE_SIZE) == -1) {
        perror("ftruncate");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 创建存储映射区
    mapped_memory = mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mapped_memory == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 写入数据到映射区
    strcpy(mapped_memory, "Hello from Process 1!");

    // 保持程序运行一段时间，以便进程2读取
    sleep(30);

    // 解除映射
    if (munmap(mapped_memory, FILE_SIZE) == -1) {
        perror("munmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 关闭文件
    close(fd);

    return 0;
}

读进程：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>

#define FILE_PATH "shared_file.txt"
#define FILE_SIZE 4096

int main() {
    int fd;
    char *mapped_memory;

    // 打开文件
    fd = open(FILE_PATH, O_RDWR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 创建存储映射区
    mapped_memory = mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mapped_memory == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 读取映射区中的数据
    printf("Process 2 reads: %s\n", mapped_memory);

    // 修改映射区中的数据
    strcpy(mapped_memory, "Hello from Process 2!");

    // 保持程序运行一段时间，以便进程1看到修改
    sleep(30);

    // 解除映射
    if (munmap(mapped_memory, FILE_SIZE) == -1) {
        perror("munmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 关闭文件
    close(fd);

    return 0;
}

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

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

相关文章

国外UI设计赏析—汽车行业

国外UI设计赏析—汽车行业

国外汽车网页设计界面往往展现出几个显著的优点&#xff0c;这些优点不仅提升了用户体验&#xff0c;还增强了品牌形象与产品吸引力。首先&#xff0c;它们注重界面设计的直观性与互动性&#xff0c;通过高清大图、动态效果以及简洁明了的布局&#xff0c;让用户能够一目了然地…
阅读更多...
王老师 linux c++ 通信架构 笔记（一）linux虚拟机的安装

王老师 linux c++ 通信架构 笔记（一）linux虚拟机的安装

&#xff08;0&#xff09;本门课程会涉及很多知识。在此集中记录&#xff0c;做笔记&#xff0c;也可能加入别的专栏。 &#xff08;1&#xff09; vmware 15 的下载和密钥上网查找。 ubuntu - 16 - 04 的版本才 800 M &#xff0c;来 csdn 找镜像 下载。 &#xff08;2&#…
阅读更多...
动态sql 单选变多选

动态sql 单选变多选

实体类 添加数组存储值 private ArrayList tssjfjList; <!-- <if test"tssjfj ! null and tssjfj ! ">and tssjfj #{tssjfj}</if>--><if test"tssjfjList ! null and tssjfjList.size() > 0">AND tssjfj IN<fo…
阅读更多...
《昇思25天学习打卡营第20天|Diffusion扩散模型》

《昇思25天学习打卡营第20天|Diffusion扩散模型》

#学习打卡第20天# Diffusion扩散模型 本文的介绍是基于denoising diffusion probabilistic model &#xff08;DDPM&#xff09;&#xff0c;DDPM已经在&#xff08;无&#xff09;条件图像/音频/视频生成领域取得了较多显著的成果&#xff0c;现有的比较受欢迎的的例子包括由O…
阅读更多...
2024年，搞AI就别卷模型了

2024年，搞AI就别卷模型了

你好&#xff0c;我是三桥君 2022年11月30日&#xff0c;OpenAI发布了一款全新的对话式通用人工智能工具——ChatGPT。 该工具发布后&#xff0c;仅用5天时间就吸引了100万活跃用户&#xff0c;而在短短2个月内&#xff0c;其活跃用户数更是飙升至1亿&#xff0c;成为历史上增…
阅读更多...
牛顿黏滞定律

牛顿黏滞定律

牛顿黏滞定律描述了流体内部的剪切应力与速度梯度之间的关系。公式如下&#xff1a; τ η d v x d y \tau \eta \frac{dv_x}{dy} τηdydvx​​ 其中&#xff1a; τ \tau τ 是剪切应力&#xff08;shear stress&#xff09;&#xff0c;单位是帕斯卡&#xff08;Pa&…
阅读更多...
互信息（Mutual Information，MI）的原理和计算

互信息（Mutual Information，MI）的原理和计算

互信息&#xff08;Mutual Information&#xff0c;MI&#xff09;是信息论中的一个度量&#xff0c;用于量化两个随机变量之间的依赖关系。互信息度量了一个随机变量包含了关于另一个随机变量的信息量。它可以用来识别和量化两个信号之间的非线性相关性。互信息可以揭示两个信…
阅读更多...
Web开发：一个可拖拽的模态框（HTML、CSS、JavaScript）

Web开发：一个可拖拽的模态框（HTML、CSS、JavaScript）

目录 一、需求描述 二、实现效果 三、完整代码 四、实现过程 1、HTML 页面结构 2、CSS 元素样式 3、JavaScript动态控制 &#xff08;1&#xff09;获取元素 &#xff08;2&#xff09;显示\隐藏遮罩层与模态框 &#xff08;3&#xff09;实现模态框拖动效果 一、需求…
阅读更多...
【离线查询 堆 优先队列】1383. 最大的团队表现值

【离线查询 堆 优先队列】1383. 最大的团队表现值

本文涉及知识点 离线查询 堆 优先队列 算法与数据结构汇总 LeetCode1383. 最大的团队表现值 给定两个整数 n 和 k&#xff0c;以及两个长度为 n 的整数数组 speed 和 efficiency。现有 n 名工程师&#xff0c;编号从 1 到 n。其中 speed[i] 和 efficiency[i] 分别代表第 i 位…
阅读更多...
开源项目的认识理解

开源项目的认识理解

目录 开源项目有哪些机遇与挑战&#xff1f; 1.开源项目的发展趋势 2.开源的经验分享&#xff08;向大佬请教与上网查询&#xff09; 3.开源项目的挑战 开源项目有哪些机遇与挑战&#xff1f; 1.开源项目的发展趋势 1. 持续增长与普及 - 开源项目将继续增长&#xff0c…
阅读更多...
软件测试——AI快速入门

软件测试——AI快速入门

工作职责&#xff1a; 1.负责产品系统测试&#xff0c;包括功能测试、性能测试、稳定性测试、用户场景测试、可靠性测试等。 2.负责测试相关文档的编写&#xff0c;包括测试计划、测试用例、测试报告等。 3.负责自动化测试框架、用例的维护。 岗位要求&#xff1a; 1.熟练…
阅读更多...
编程范式之并发编程

编程范式之并发编程

目录 前言1. 并发编程的定义2. 并发编程的特点2.1 任务交替执行2.2 状态共享与同步2.3 并行执行 3. 并发编程的适用场景3.1 高性能计算3.2 I/O 密集型应用3.3 实时系统 4. 并发编程的优点4.1 提高资源利用率4.2 缩短响应时间4.3 提高系统吞吐量 5. 并发编程的缺点5.1 编程复杂性…
阅读更多...
MP4怎么转为MP3？超多人都在用的四种转换方法！

MP4怎么转为MP3？超多人都在用的四种转换方法！

MP4怎么转为MP3&#xff1f;MP4&#xff0c;这一风靡全球的多媒体容器格式&#xff0c;无疑是数字时代的一枚璀璨明珠&#xff0c;深深烙印在每个人的数字生活之中&#xff0c;那么&#xff0c;它究竟是如何在众多格式中脱颖而出&#xff0c;赢得如此广泛认可的呢&#xff1f;首…
阅读更多...
【Redis】初识 Redis

【Redis】初识 Redis

文章目录 1 什么是 Redis2 Redis 的特点2.1 速度快2.2 可编程性2.3 可拓展性2.4 持久化2.5 主从复制2.5 高可用和分布式2.6 客户端语言多 3 Redis 使用场景3.1 实时数据存储3.2 缓存和 Session 存储3.3 消息队列 4 Redis 重大版本5 CentOS7 安装 Redis5 1 什么是 Redis Redis …
阅读更多...
【typedb】例子：药物发现 1： 模式导入

【typedb】例子：药物发现 1： 模式导入

typedb-examples/drug-discovery/ Drug discovery监听0.0.0.0:1729 但这么连接肯定不行： localhost:1729 可以： 一直无法点击schema图标：先创建一个数据库 选中数据库： 选中后就可以了：
阅读更多...
分布式存储快速入门HDFS

分布式存储快速入门HDFS

分布式存储快速入门 文章目录 分布式存储快速入门一、概要介绍1.1 什么是分布式存储1.2 分布式存储的重要性和应用场景 二、HDFS基础2.1 HDFS的起源和发展2.2 HDFS的架构2.3 HDFS的基本概念2.4 HDFS的特性2.5 HDFS的版权 三、HDFS安装与配置3.1 环境准备3.2 安装Hadoop和配置HD…
阅读更多...
你也想做一个Element-ui吧！！！——Blueの前端路（一）

你也想做一个Element-ui吧！！！——Blueの前端路（一）

目录 前言&#xff1a; 父子组件 button组件 使用vue脚手架初始化一个项目 如何封装&#xff0c;注册和使用一个组件 main.js中将组件设置为全局 使用 此组件我们所需实现的内容 type 父组件组件传递type属性 子组件接收负组件传递的数据 通过绑定类名的方法动态控制…
阅读更多...
python如何结束程序运行

python如何结束程序运行

方法1&#xff1a;采用sys.exit(0)&#xff0c;正常终止程序&#xff0c;从图中可以看到&#xff0c;程序终止后shell运行不受影响。 方法2&#xff1a;采用os._exit(0)关闭整个shell&#xff0c;从图中看到&#xff0c;调用sys._exit(0)后整个shell都重启了&#xff08;RESTAR…
阅读更多...
关键路径-matlab

关键路径-matlab

路径上边的数目称为路径长度 图的基本知识 求最短路径&#xff08;Dijkstra算法&#xff09; 2. 待继续尝试 ①Dijkstra ②floyd_all.m 一 二 ③ LeetCode [329. 矩阵中的最长递增路径]
阅读更多...
OpenCV solvePnP位姿估计

OpenCV solvePnP位姿估计

目录 一、概述 二、实现代码 2.1solvePnP函数 2.1.1输入参数 2.1.2输出参数 2.2完整代码 三、实现效果 3.1标定板位姿 3.2标定板到相机的变换矩阵 一、概述 完成相机标定后&#xff0c;可以通过检测标定板在图像中的位置来计算标定板在相机坐标系下的位姿&#xff08;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023