是否存在任何方法（无论是 Linux 特定的还是非特定的），可以使 POSIX 共享内存段（使用 shm_open() 获得）在没有进程使用它们时被删除。即，将它们引用计数，并在引用计数变为 0 时系统删除它们。
以下是一些注意事项：
建立一个 atexit 处理程序来删除它们，在程序崩溃时不起作用。
目前，Linux 特定的方法是在段名称中嵌入 pid，并尝试在外部程序中遍历 /dev/shm 找到未使用的段。这种方法的缺点是需要以相当 hackish 的方式定期在外部进行清理。
由于程序可以运行多个副本，因此在启动时为段使用一个明确定义的名称并不可行。
shm_open()，则会创建一个全新且完全不同的共享内存块。不行 - 至少在 Linux 上，内核中没有任何可以执行此操作的内容。某个应用程序需要在某个时刻调用shm_unlink()来摆脱共享内存段。
std::string shm_file = "/dev/shm/" + service_name + "Shm";
std::string cmd_line = "if [ -f " + shm_file + " ] ; then if ! fuser -s " + shm_file + " ; then rm -f " + shm_file + " ; else exit 2 ; fi else exit 3 ; fi";
int res = system(cmd_line.c_str());
switch (WEXITSTATUS(res)) {
case 0: _logger.warning ("The shared memory file " + shm_file + " was found orphan and is deleted"); break;
case 1: _logger.critical("The shared memory file " + shm_file + " was found orphan and cannot be deleted"); break;
case 2: _logger.trace ("The shared memory file " + shm_file + " is linked to alive processes"); break;
case 3: _logger.trace ("The shared memory file " + shm_file + " is not found"); break;
}
让我们假设最复杂的情况：
我看到两种可能的解决方案，并希望对它们进行反馈，因为互联网对这个问题鲜有回应：
Store the pid (or a more specific process identifier if you have one) of the last process that wrote to the shared memory inside the shared memory as a lock. Then you could do sth. like the following pseudo code:
int* pshmem = open shared memory()
while(true)
nPid = atomic_read(pshmem)
if nPid = 0
// your shared memory is in a valid state
break
else
// process nPid holds a lock to your shared memory
// or it might have crashed while holding the lock
if process nPid still exists
// shared memory is valid
break
else
// shared memory is corrupt
// try acquire lock
if atomic_compare_exchange(pshmem, nPid, my pid)
// we have the lock
reinitialize shared memory
atomic_write(pshem, 0) // release lock
else
// somebody else got the lock in the meantime
// continue loop
This verifies that the last writer didn't die while writing. The shared memory is still persisting longer than any of your processes.
Use a reader/writer file lock to find out if any process is the first process opening the shared memory object. The first process may then reinitialize the shared memory:
// try to get exclusive lock on lockfile
int fd = open(lockfile, O_RDONLY | O_CREAT | O_EXLOCK | O_NONBLOCK, ...)
if fd == -1
// didn't work, somebody else has it and is initializing shared memory
// acquire shared lock and wait for it
fd = open(lockfile, O_RDONLY | O_SHLOCK)
// open shared memory
else
// we are the first
// delete shared memory object
// possibly delete named mutex/semaphore as well
// create shared memory object (& semaphore)
// degrade exclusive lock to a shared lock
flock(fd, LOCK_SH)
File locks seem to be the only (?) mechanism on POSIX systems that is cleared up automatically when the process dies. Unfortunately, the list of caveats to use them is very, very long. The algorithm assumes flock is supported on the underlying filesystem at least on the local machine. The algorithm doesn't care if the locks are actually visible to other processes on NFS filesystems or not. They only have to be visible for all processes accessing the shared memory object.
This solution has been implemented on top of boost.interprocess.
open(lockfile, O_RDONLY | O_CREAT | O_EXLOCK | O_NONBLOCK, ...) 如果该文件不存在，则会创建它，否则将打开现有的文件。 - Sebastian不确定以下是否可行。但是我会尝试。
为什么不执行辅助程序，每次您的程序崩溃时都会执行它。
例如：
/proc/sys/kernel/core_pattern to /path/to/Myprogram %p
当进程崩溃时，我的程序会被执行，你可以进一步探索。
请查看。
man 5 core. for more information.
希望这能在一定程度上有所帮助。
你能不能使用全局计数信号量来进行引用计数？在附加和分离调用时包装信号量，以便在附加到内存时增加信号量，在分离时减少信号量。当分离操作将信号量减少到零时释放该段。