当前位置： 首页 > news >正文

Android学习19 -- NDK4--共享内存（TODO）

news 2025/7/4 10:54:34

在安卓的NDK（Native Development Kit）中，C++共享内存通常用于不同进程间的通信，或者在同一进程中多线程之间共享数据。这种方法相较于其他形式的IPC（进程间通信）来说，具有更高的性能和低延迟。共享内存提供了一块可以被多个进程访问的内存区域，但它的使用需要小心，以避免并发问题和内存访问冲突。

以下是如何在安卓NDK下使用C++进行共享内存的一些基本概念和实现方法：

1. 使用 ashmem（Android共享内存）

Android提供了ashmem（Android Shared Memory）用于跨进程共享内存。它是安卓平台上特定于共享内存的一种机制，可以通过文件描述符来实现共享内存区域。

基本步骤：

  1. 创建共享内存： 使用ashmem_create_region()函数创建共享内存区域。

    #include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <ashmem.h>int create_shared_memory(size_t size) {int fd = ashmem_create_region("my_shared_memory", size);if (fd < 0) {perror("Failed to create shared memory");return -1;}return fd;
}

  2. 映射共享内存： 使用mmap函数将共享内存映射到进程的虚拟地址空间。

    void* map_shared_memory(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}

  3. 写入/读取共享内存： 映射后，可以直接通过指针访问共享内存。

    void write_to_shared_memory(void* addr, const char* data) {memcpy(addr, data, strlen(data) + 1);
}void read_from_shared_memory(void* addr) {printf("Data from shared memory: %s\n", (char*)addr);
}

  4. 关闭共享内存： 使用munmap和close来卸载和关闭共享内存。

    void unmap_shared_memory(void* addr, size_t size) {munmap(addr, size);
}void close_shared_memory(int fd) {close(fd);
}

2. 使用 mmap 和普通文件

如果需要跨进程共享内存，可以使用mmap映射一个物理文件作为共享内存。文件在磁盘上存在，但多个进程可以通过映射来共享这个文件的内存区域。

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>int create_shared_memory_file(const char* path, size_t size) {int fd = open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);if (fd == -1) {perror("Failed to open file");return -1;}if (ftruncate(fd, size) == -1) {perror("Failed to set file size");close(fd);return -1;}return fd;
}void* map_shared_memory_file(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}void unmap_shared_memory(void* addr, size_t size) {munmap(addr, size);
}

3. 线程间共享内存

在同一进程中的多个线程也可以通过共享内存来交换数据。共享内存在多线程场景下的使用是非常常见的，因为它允许线程直接访问共享数据，而无需进行复杂的序列化。

#include <pthread.h>
#include <atomic>std::atomic<int> shared_counter(0);void* thread_func(void* arg) {shared_counter.fetch_add(1, std::memory_order_relaxed);return nullptr;
}int main() {pthread_t threads[10];for (int i = 0; i < 10; ++i) {pthread_create(&threads[i], nullptr, thread_func, nullptr);}for (int i = 0; i < 10; ++i) {pthread_join(threads[i], nullptr);}printf("Shared counter: %d\n", shared_counter.load());return 0;
}

4. 注意事项

  • 同步问题：共享内存的访问需要确保线程或进程间的同步。可以使用mutex、semaphore或其他同步机制来防止竞态条件。

  • 资源管理：共享内存资源需要适当管理，避免内存泄漏。确保共享内存被正确地映射、使用和释放。

  • 权限控制：对于跨进程的共享内存，必须确保各个进程具有访问该内存区域的权限，否则可能会导致访问错误。

总结

安卓NDK中使用C++进行共享内存操作主要通过ashmem或mmap来实现。ashmem是专为Android设计的共享内存机制，适用于跨进程通信；而mmap可以用于映射普通文件作为共享内存。共享内存在多进程和多线程之间的数据交换中非常有用，但需要注意同步和资源管理的问题。

在安卓NDK下，多个进程共享一个共享内存的例子通常可以通过ashmem（Android共享内存）来实现。ashmem允许不同的进程通过文件描述符访问同一块内存区域，从而实现跨进程的共享内存通信。

下面是一个简单的例子，展示了如何使用ashmem在两个进程间共享内存。进程A写入共享内存，进程B读取共享内存。

步骤概述：

  1. 进程A：创建共享内存并将数据写入内存。
  2. 进程B：访问同一共享内存并读取数据。

1. 进程A：创建共享内存并写入数据

进程A代码 (process_a.cpp)
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <ashmem.h>int create_shared_memory(size_t size) {int fd = ashmem_create_region("my_shared_memory", size);if (fd < 0) {perror("Failed to create shared memory");return -1;}return fd;
}void* map_shared_memory(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}int main() {const size_t size = 1024;  // 定义共享内存大小const char* message = "Hello from Process A!";// 创建共享内存int fd = create_shared_memory(size);if (fd < 0) {return 1;}// 映射共享内存void* addr = map_shared_memory(fd, size);if (addr == nullptr) {close(fd);return 1;}// 将数据写入共享内存strncpy((char*)addr, message, size);printf("Process A: Written to shared memory: %s\n", message);// 关闭共享内存munmap(addr, size);close(fd);return 0;
}

2. 进程B：访问共享内存并读取数据

进程B代码 (process_b.cpp)
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <ashmem.h>void* map_shared_memory(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}int main() {const size_t size = 1024;  // 定义共享内存大小// 打开已有的共享内存文件描述符int fd = open("/dev/ashmem/my_shared_memory", O_RDONLY);if (fd < 0) {perror("Failed to open shared memory");return 1;}// 映射共享内存void* addr = map_shared_memory(fd, size);if (addr == nullptr) {close(fd);return 1;}// 读取共享内存中的数据printf("Process B: Read from shared memory: %s\n", (char*)addr);// 关闭共享内存munmap(addr, size);close(fd);return 0;
}

3. 编译和运行

  1. 编译代码： 你需要将process_a.cpp和process_b.cpp分别编译成独立的可执行文件。

    在终端中使用NDK编译工具（如ndk-build或CMake）编译代码。确保设置正确的NDK环境。

    例如，使用CMake时，创建一个CMakeLists.txt文件来设置编译参数：

    cmake_minimum_required(VERSION 3.4.1)add_executable(process_a process_a.cpp)
add_executable(process_b process_b.cpp)

    使用CMake进行构建：

    mkdir build
cd build
cmake ..
make

  2. 运行进程A： 启动进程A，它会创建共享内存并写入数据。

    ./process_a

  3. 运行进程B： 启动进程B，它会读取进程A写入共享内存中的数据。

    ./process_b

4. 说明

  • 创建共享内存：进程A通过调用ashmem_create_region()函数来创建共享内存。这个函数返回一个文件描述符，可以通过该文件描述符在其他进程中访问共享内存。

  • 映射共享内存：进程A和进程B通过mmap()函数将共享内存映射到各自的地址空间，读取或写入共享内存的数据。

  • 数据传输：进程A将数据写入共享内存，进程B从共享内存读取数据。这两者通过共享内存实现了数据传输。

  • 进程间共享内存访问：共享内存的访问方式是基于文件描述符的，通过文件描述符，可以在不同的进程之间共享这块内存。ashmem是一种轻量级的共享内存方式，适用于安卓中的跨进程数据共享。

5. 注意事项

  • 由于共享内存没有内建的同步机制，多个进程同时访问时需要通过锁（例如mutex、semaphore）来保证数据一致性。
  • 在实际开发中，可能还需要设置共享内存的权限（如只读或读写），以保证数据的安全性。

通过这个例子，你可以看到如何在安卓NDK中使用C++进行共享内存的创建和访问，实现多个进程间的数据共享。

在安卓NDK下，使用共享内存实现生产者消费者模型，涉及多个进程通过共享内存进行数据交换。一个进程作为生产者写入数据，多个消费者进程从共享内存中读取数据。

关键概念：

  1. 共享内存：生产者和消费者进程使用共享内存区域进行数据交换。ashmem是一个适用于安卓的共享内存机制。
  2. 同步机制：由于多个进程访问共享内存，必须确保数据一致性和避免竞争条件。因此，使用同步机制（如信号量）来控制数据的读写。

示例描述：

  • 生产者进程：产生数据并写入共享内存。
  • 消费者进程：从共享内存中读取数据并消费。

为了实现这一模型，我们将使用ashmem来创建共享内存区域，并使用简单的信号量（例如通过sem_t）来同步进程之间的读写。

1. 数据结构和共享内存设计

首先定义一个简单的共享内存结构，其中包括一个缓冲区、读写指针和信号量，用于同步。

// shared_memory.h
#ifndef SHARED_MEMORY_H
#define SHARED_MEMORY_H#include <semaphore.h>#define BUFFER_SIZE 10  // 缓冲区大小// 共享内存结构
struct shared_memory {int buffer[BUFFER_SIZE];   // 数据缓冲区int read_index;            // 读取位置int write_index;           // 写入位置sem_t full;                // 缓冲区中的数据数量sem_t empty;               // 缓冲区中的空位数量sem_t mutex;               // 互斥锁，保护缓冲区的读写
};#endif

2. 生产者进程（写入共享内存）

生产者进程不断生成数据，并将数据写入共享内存。在每次写入后，生产者会通知消费者进程。

生产者代码 (producer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <semaphore.h>
#include <string.h>
#include "shared_memory.h"
#include <ashmem.h>int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 写入数据的生产者循环for (int i = 0; i < 100; ++i) {// 等待空槽位sem_wait(&shm->empty);sem_wait(&shm->mutex);// 生成数据并写入缓冲区shm->buffer[shm->write_index] = i;printf("Producer: produced %d\n", i);// 更新写入位置shm->write_index = (shm->write_index + 1) % BUFFER_SIZE;// 释放互斥锁，通知消费者sem_post(&shm->mutex);sem_post(&shm->full);// 模拟生产者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

3. 消费者进程（读取共享内存）

消费者进程从共享内存中读取数据，并进行消费。在每次读取后，消费者会通知生产者进程。

消费者代码 (consumer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <semaphore.h>
#include <string.h>
#include "shared_memory.h"
#include <ashmem.h>int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 消费者循环for (int i = 0; i < 100; ++i) {// 等待缓冲区中有数据sem_wait(&shm->full);sem_wait(&shm->mutex);// 从缓冲区读取数据int item = shm->buffer[shm->read_index];printf("Consumer: consumed %d\n", item);// 更新读取位置shm->read_index = (shm->read_index + 1) % BUFFER_SIZE;// 释放互斥锁，通知生产者sem_post(&shm->mutex);sem_post(&shm->empty);// 模拟消费者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

4. 创建和初始化共享内存

共享内存需要在生产者和消费者进程启动前创建，并初始化必要的信号量。这里我们需要一个初始化共享内存的代码。

初始化共享内存 (init_shared_memory.cpp)
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <semaphore.h>
#include <string.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 创建共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);if (fd == -1) {perror("Failed to create shared memory");return -1;}// 设置共享内存大小if (ftruncate(fd, sizeof(struct shared_memory)) == -1) {perror("Failed to set memory size");close(fd);return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 初始化缓冲区shm->read_index = 0;shm->write_index = 0;// 初始化信号量sem_init(&shm->full, 1, 0);       // full: initially 0sem_init(&shm->empty, 1, BUFFER_SIZE);  // empty: initially BUFFER_SIZEsem_init(&shm->mutex, 1, 1);      // mutex: initially unlocked (1)// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);printf("Shared memory initialized.\n");return 0;
}

5. 编译和运行

首先编译这三个程序：init_shared_memory.cpp、producer.cpp 和 consumer.cpp。

g++ init_shared_memory.cpp -o init_shared_memory -lstdc++ -lpthread
g++ producer.cpp -o producer -lstdc++ -lpthread
g++ consumer.cpp -o consumer -lstdc++ -lpthread

然后，按照以下顺序执行：

  1. 初始化共享内存： 在任何生产者或消费者进程运行之前，先运行初始化共享内存的程序。

    ./init_shared_memory

  2. 启动生产者进程： 启动生产者进程，它会开始生成数据并写入共享内存。

    ./producer

  3. 启动消费者进程： 启动多个消费者进程，读取共享内存中的数据。

    ./consumer

    可以启动多个消费者进程，如：

    ./consumer &
./consumer &

总结

在这个例子中，我们通过共享内存和信号量实现了生产者-消费者模式。生产者通过共享内存写入数据，多个消费者读取并消费数据。信号量确保了在多进程环境中对共享内存的同步访问。

在安卓 NDK 中使用 C++ 和共享内存实现生产者消费者模型，且采用 条件变量 进行同步，需要确保生产者和消费者在共享内存的读写操作中正确同步。

关键步骤：

  1. 共享内存：使用 ashmem 共享内存来传递数据。
  2. 互斥锁和条件变量：使用 pthread_mutex_t 和 pthread_cond_t 来实现生产者和消费者的同步。

示例设计：

  • 生产者进程：生成数据并写入共享内存。
  • 消费者进程：从共享内存中读取数据并进行消费。
  • 通过条件变量来保证数据写入和读取的同步：
    • 生产者在缓冲区满时等待。
    • 消费者在缓冲区空时等待。

1. 数据结构和共享内存设计

// shared_memory.h
#ifndef SHARED_MEMORY_H
#define SHARED_MEMORY_H#include <pthread.h>#define BUFFER_SIZE 10  // 缓冲区大小// 共享内存结构
struct shared_memory {int buffer[BUFFER_SIZE];   // 数据缓冲区int read_index;            // 读取位置int write_index;           // 写入位置pthread_mutex_t mutex;     // 互斥锁，保护缓冲区的读写pthread_cond_t full_cond;  // 条件变量，缓冲区满时等待pthread_cond_t empty_cond; // 条件变量，缓冲区空时等待
};#endif

2. 初始化共享内存

初始化共享内存区域，包括互斥锁和条件变量。

初始化共享内存 (init_shared_memory.cpp)
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 创建共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);if (fd == -1) {perror("Failed to create shared memory");return -1;}// 设置共享内存大小if (ftruncate(fd, sizeof(struct shared_memory)) == -1) {perror("Failed to set memory size");close(fd);return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 初始化缓冲区shm->read_index = 0;shm->write_index = 0;// 初始化互斥锁和条件变量pthread_mutex_init(&shm->mutex, NULL);pthread_cond_init(&shm->full_cond, NULL);pthread_cond_init(&shm->empty_cond, NULL);// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);printf("Shared memory initialized.\n");return 0;
}

3. 生产者进程（写入共享内存）

生产者进程会不断生成数据并将其写入共享内存。当缓冲区满时，生产者会等待，直到消费者消费一些数据。

生产者代码 (producer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <pthread.h>
#include <string.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 写入数据的生产者循环for (int i = 0; i < 100; ++i) {pthread_mutex_lock(&shm->mutex);// 如果缓冲区满，则等待while ((shm->write_index + 1) % BUFFER_SIZE == shm->read_index) {pthread_cond_wait(&shm->full_cond, &shm->mutex);}// 生成数据并写入缓冲区shm->buffer[shm->write_index] = i;printf("Producer: produced %d\n", i);// 更新写入位置shm->write_index = (shm->write_index + 1) % BUFFER_SIZE;// 通知消费者数据已准备好pthread_cond_signal(&shm->empty_cond);pthread_mutex_unlock(&shm->mutex);// 模拟生产者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

4. 消费者进程（读取共享内存）

消费者进程会从共享内存中读取数据并进行消费。当缓冲区为空时，消费者会等待，直到生产者写入数据。

消费者代码 (consumer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <pthread.h>
#include <string.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 消费者循环for (int i = 0; i < 100; ++i) {pthread_mutex_lock(&shm->mutex);// 如果缓冲区空，则等待while (shm->read_index == shm->write_index) {pthread_cond_wait(&shm->empty_cond, &shm->mutex);}// 从缓冲区读取数据int item = shm->buffer[shm->read_index];printf("Consumer: consumed %d\n", item);// 更新读取位置shm->read_index = (shm->read_index + 1) % BUFFER_SIZE;// 通知生产者可以继续写入pthread_cond_signal(&shm->full_cond);pthread_mutex_unlock(&shm->mutex);// 模拟消费者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

5. 编译和运行

首先编译这三个程序：init_shared_memory.cpp、producer.cpp 和 consumer.cpp。

g++ init_shared_memory.cpp -o init_shared_memory -lstdc++ -lpthread
g++ producer.cpp -o producer -lstdc++ -lpthread
g++ consumer.cpp -o consumer -lstdc++ -lpthread

然后，按照以下顺序执行：

  1. 初始化共享内存： 在任何生产者或消费者进程运行之前，先运行初始化共享内存的程序。

    ./init_shared_memory

  2. 启动生产者进程： 启动生产者进程，它会开始生成数据并写入共享内存。

    ./producer

  3. 启动消费者进程： 启动多个消费者进程，读取共享内存中的数据。

    ./consumer

    可以启动多个消费者进程，如：

    ./consumer &
./consumer &

总结

在这个例子中，我们使用了 条件变量 来实现生产者消费者模型。在每次写入和读取数据时，生产者和消费者会根据缓冲区的状态进行等待和通知，从而保证了数据的一致性。信号量可以用来控制资源的访问，而条件变量则提供了更灵活的同步机制，尤其是在等待和通知特定条件时。

http://www.lryc.cn/news/510465.html

相关文章：

  • 《Cocos Creator游戏实战》非固定摇杆实现原理
  • RabbitMQ工作模式（详解 工作模式：简单队列、工作队列、公平分发以及消息应答和消息持久化）
  • 【VScode】第三方GPT编程工具-CodeMoss安装教程
  • 在JavaScript中，let 和 const有什么不同
  • Mysq学习-Mysql查询（4）
  • 安装torch-geometric库
  • Java数组深入解析：定义、操作、常见问题与高频练习
  • Docker-构建自己的Web-Linux系统-镜像webtop:ubuntu-kde
  • 【C语言练习（17）—输出杨辉三角形】
  • SpringMVC学习(二)——RESTful API、拦截器、异常处理、数据类型转换
  • React 第二十节 useRef 用途使用技巧注意事项详解
  • VIVO Java开发面试题及参考答案
  • C# Winfrom chart图 实例练习
  • iOS从Matter的设备认证证书中获取VID和PID
  • 带着国标充电器出国怎么办？ 适配器模式（Adapter Pattern）
  • 破解海外业务困局：新加坡服务器托管与跨境组网策略
  • Mybatis-Plus快速入门
  • Chrome被360导航篡改了怎么改回来？
  • Coding（Jenkinsfile）+ Docker 自动化部署 Springboot —— 图文细节和一些注意事项说明
  • docker django uwsgi 报错记录
  • 数据分析思维（五）：分析方法——假设检验分析方法
  • 【ES6复习笔记】集合Set（13）
  • 基础爬虫案例实战
  • 深度学习工作：从追求 SoTA 到揭示新现象
  • 学习记录—正则表达式-基本语法
  • 智慧农业物联网传感器:开启农业新时代
  • 普通人怎么入门学习并使用AI？
  • Java中处理if-else的几种高级方法
  • 前端知识补充—CSS
  • 企业架构学习笔记-数字化转型