Algorithm FIFO队列同步

如果只有一个读卡器和一个写卡器，是否应该同步FIFO队列？

是，如果读卡器和写卡器从不同线程与FIFO队列交互。

是，如果读卡器和写卡器从不同线程与FIFO队列交互。

取决于实现，但最有可能是这样。您不希望读卡器读取部分写入的数据。

这取决于实现，但最有可能的情况是。您不希望读卡器读取部分写入的数据。

是的，除非其文档明确说明了其他内容

---

（如果只有一个读卡器线程和一个写卡器线程，则可以实现不需要同步的专用FIFO，例如，在使用InterlockedXXX函数的Windows上。）

是，除非其文档明确另有说明

（如果只有一个读卡器线程和一个写卡器线程，则可以实现不需要同步的专用FIFO，例如在使用InterconnectedXXX函数的Windows上。）

您所说的“同步”是什么意思？如果读写器处于不同的线程中，则需要FIFO“正确”处理并发，包括以下详细信息：

• 正确使用FIFO API不应导致数据结构损坏
• 正确使用FIFO API不应导致死锁（尽管应该有一种机制让读卡器等待，直到有东西要读）
• 从FIFO读取的对象应该是以相同顺序写入FIFO的相同对象（不应该缺少对象或重新排列顺序）
• 从编写者将某个内容放入FIFO到读者可以使用它之间应该有一个有限的时间（希望如此！）

在Java世界中，有一本关于这方面的好书。有多种方法可以实现正确处理并发性的FIFO。最简单的实现是阻塞，更复杂的实现使用基于当前大多数处理器上的比较和交换指令的非阻塞算法。

你所说的“同步”是什么意思？如果读写器处于不同的线程中，则需要FIFO“正确”处理并发，包括以下详细信息：

• 正确使用FIFO API不应导致数据结构损坏
• 正确使用FIFO API不应导致死锁（尽管应该有一种机制让读卡器等待，直到有东西要读）
• 从FIFO读取的对象应该是以相同顺序写入FIFO的相同对象（不应该缺少对象或重新排列顺序）
• 从编写者将某个内容放入FIFO到读者可以使用它之间应该有一个有限的时间（希望如此！）

---

在Java世界中，有一本关于这方面的好书。有多种方法可以实现正确处理并发性的FIFO。最简单的实现是阻塞，更复杂的实现使用基于当前大多数处理器上的比较和交换指令的非阻塞算法。

请尝试以下代码以同时使用fifo：

public class MyObjectQueue {

private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

private static final ReadLock readLock;

private static final WriteLock writeLock;

private static final LinkedList<MyObject> objects;

static {
    readLock = lock.readLock();
    writeLock = lock.writeLock();
    objects = new LinkedList<MyObject>();
}

public static boolean put(MyObject p) {
    writeLock.lock();
    try {
        objects.push(p);            
        return objects.contains(p);
    } finally {
        writeLock.unlock();
    }
}

public static boolean remove(MyObject p) {
    writeLock.lock();
    try {
        return objects.remove(p);           
    } finally {
        writeLock.unlock();
    }
}

public static boolean contains(MyObject p) {
    readLock.lock();
    try {
        return objects.contains(p);         
    } finally {
        readLock.unlock();
    }
}   

public MyObject get() {
    MyObject o = null;
    writeLock.lock();
    try {
        o = objects.getLast();
    } catch (NoSuchElementException nse) {
        //list is empty
    } finally {
        writeLock.unlock();
    }
    return o;
}

公共类MyObject队列{
私有静态最终ReentrantReadWriteLock锁=新的ReentrantReadWriteLock（）；
私有静态最终读锁读锁；
私有静态最终写回写回；
私有静态最终LinkedList对象；
静止的{
readLock=lock.readLock（）；
writeLock=lock.writeLock（）；
对象=新的LinkedList（）；
}
公共静态布尔put（MyObject p）{
writeLock.lock（）；
试一试{
物体。推（p）；
返回objects.contains（p）；
}最后{
writeLock.unlock（）；
}
}
公共静态布尔删除（MyObject p）{
writeLock.lock（）；
试一试{
返回对象。移除（p）；
}最后{
writeLock.unlock（）；
}
}
公共静态布尔包含（MyObject p）{
readLock.lock（）；
试一试{
返回objects.contains（p）；
}最后{
readLock.unlock（）；
}
}   
公共MyObject get（）{
MyObject o=null；
writeLock.lock（）；
试一试{
o=objects.getLast（）；
}捕获（非接触元素异常nse）{
//列表为空
}最后{
writeLock.unlock（）；
}
返回o；
}

---

}

请尝试以下代码以同时使用fifo：

public class MyObjectQueue {

private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

private static final ReadLock readLock;

private static final WriteLock writeLock;

private static final LinkedList<MyObject> objects;

static {
    readLock = lock.readLock();
    writeLock = lock.writeLock();
    objects = new LinkedList<MyObject>();
}

public static boolean put(MyObject p) {
    writeLock.lock();
    try {
        objects.push(p);            
        return objects.contains(p);
    } finally {
        writeLock.unlock();
    }
}

public static boolean remove(MyObject p) {
    writeLock.lock();
    try {
        return objects.remove(p);           
    } finally {
        writeLock.unlock();
    }
}

public static boolean contains(MyObject p) {
    readLock.lock();
    try {
        return objects.contains(p);         
    } finally {
        readLock.unlock();
    }
}   

public MyObject get() {
    MyObject o = null;
    writeLock.lock();
    try {
        o = objects.getLast();
    } catch (NoSuchElementException nse) {
        //list is empty
    } finally {
        writeLock.unlock();
    }
    return o;
}

公共类MyObject队列{
私有静态最终ReentrantReadWriteLock锁=新的ReentrantReadWriteLock（）；
私有静态最终读锁读锁；
私有静态最终写回写回；
私有静态最终LinkedList对象；
静止的{
readLock=lock.readLock（）；
writeLock=lock.writeLock（）；
对象=新的LinkedList（）；
}
公共静态布尔put（MyObject p）{
writeLock.lock（）；
试一试{
物体。推（p）；
返回objects.contains（p）；
}最后{
writeLock.unlock（）；
}
}
公共静态布尔删除（MyObject p）{
writeLock.lock（）；
试一试{
返回对象。移除（p）；
}最后{
writeLock.unlock（）；
}
}
公共静态布尔包含（MyObject p）{
readLock.lock（）；
试一试{
返回objects.contains（p）；
}最后{
readLock.unlock（）；
}
}   
公共MyObject get（）{
MyObject o=null；
writeLock.lock（）；
试一试{
o=objects.getLast（）；
}捕获（非接触元素异常nse）{
//列表为空
}最后{
writeLock.unlock（）；
}
返回o；
}

}