在单写入器 – 多读取器线程中交换缓冲区

故事

有一个作家线程，定期从某处（实时地收集数据，但在问题中无关紧要）收集数据。 有很多读者从这些数据中读取。 通常的解决scheme是使用两个读写器锁和两个这样的缓冲区：

Writer (case 1): acquire lock 0 loop write to current buffer acquire other lock free this lock swap buffers wait for next period 

要么

 Writer (case 2): acquire lock 0 loop acquire other lock free this lock swap buffers write to current buffer wait for next period 

问题

在这两种方法中，如果获取其他锁操作失败，则不进行交换，写入者会覆盖其以前的数据（因为写者是实时的，所以不能等待读者）所以在这种情况下，所有的读者都将丢失该帧数据的。

这并不是什么大问题，读者是我自己的代码，它们很短，所以使用双缓冲区，这个问题就解决了，如果出现问题，我可以使它成为三重缓冲区（或更多）。

• 有没有更好的方法从ARP表获取MAC地址？
• EDFalgorithm的替代
• 如何pipe理标准PC上的巨大树木？
• 在Linux上“快速select”（或类似）的实现？ （而不是sort | uniq -c | sort -rn | head – $ N）
• 什么更好：selectvs线程？

问题是我想尽量减less延迟。 想象一下情况1：

 writer writes to buffer0 reader is reading buffer1 writer can't acquire lock1 because reader is still reading buffer1 | | | reader finishes reading, | (writer waiting for next period) <- **this point** | | writer wakes up, and again writes to buffer0 

在**这一点上**，理论上其他读者可能已经读取了buffer0数据，如果只有作者可以在阅读器完成后进行交换，而不是等待下一个时期。 在这种情况下发生的事情是因为一个读者迟了一点，所有读者都错过了一个dataframe，而这个问题完全可以避免。

情况2是类似的：

 writer writes to buffer0 reader is idle | | | reader finishes reading, | (writer waiting for next period) | | reader starts reading buffer1 writer wakes up | it can't acquire lock0 because reader is still reading buffer1 overwrites buffer0 

我试着把这些解决scheme混合在一起，所以作者在写完之后立即尝试交换缓冲区，如果不可能的话，在下一个阶段才会醒来。 所以像这样的东西：

 Writer (case 3): acquire lock 0 loop if last buffer swap failed acquire other lock free this lock swap buffers write to current buffer acquire other lock free this lock swap buffers wait for next period 

现在拖延的问题仍然存在：

 writer writes to buffer0 reader is reading buffer1 writer can't acquire lock1 because reader is still reading buffer1 | | | reader finishes reading, | (writer waiting for next period) <- **this point** | | writer wakes up swaps buffers writes to buffer1 

再次在**这一点**，所有的读者可以开始读取buffer0 ，这是写入buffer0后的一个短暂的延迟，而是他们必须等到写入器的下一个周期。

问题

问题是，我该如何处理？ 如果我希望作者在期望的时间内精确执行，需要等待使用RTAI函数的时间，而我不能这样做

 Writer (case 4): acquire lock 0 loop write to current buffer loop a few times or until the buffer has been swapped sleep a little acquire other lock free this lock swap buffers wait for next period 

这引入了抖动。 因为“less数时间”可能比“等待下一个时期”长，所以作者可能会错过时期的开始。

为了更清楚一点，这是我想要发生的事情：

 writer writes to buffer0 reader is reading buffer1 | | | reader finishes reading, | (writer waiting for next period) As soon as all readers finish reading, | the buffer is swapped | readers start reading buffer0 writer wakes up | writes to buffer1 

我已经find了

我发现读取复制更新 ，据我所知，一直在为缓冲区分配内存，并释放它们，直到读者完成它们，这对我来说是不可能的，原因很多。 一，线程在内核和用户空间之间共享。 其次，使用RTAI，你不能在实时线程中分配内存（因为那么你的线程就会调用Linux的系统调用，从而打破实时性）（更不用说使用Linux自己的RCU实现是无用的出于同样的原因）

我也想过有一个额外的线程，在更高的频率尝试交换缓冲区，但这听起来不是这样一个好主意。 首先，它本身需要与作者同步;其次，我有许多这样的作家读者并行工作在不同的部分，每个作者的一个额外的线程似乎太多了。 对于所有作者来说，一个线程对于每个作者的同步来说似乎非常复杂

 void *buf[2]; void writer () { int lock = 0, next = 1; write_lock (lock); while (1) { abs_time tm = now() + period; fill (buf [lock]); if (timed_write_lock (next, tm)) { unlock (lock); lock = next; next = (next + 1) & 1; } wait_period (tm); } } void reader () { int lock = 0; while (1) { reade_lock (lock); process (buf [lock]); unlock (lock); lock = (lock + 1) & 1; } }