我对整个循环/循环缓冲思维方式都很陌生。我阅读了一些关于理论上应该如何工作的文章,并给出了这个代码示例。在我的场景中,我将有多个线程写入和一个线程从缓冲区读取。
我是否需要向写方法添加一个锁?
提前感谢!
public class CircularBuffer<T>
{
private readonly int _size;
private int _head;
private byte _headMirrorSide;
private int _tail;
private byte _tailMirrorSide;
private readonly T[] _buffer;
public CircularBuffer() : this(300) { }
public CircularBuffer(int size)
{
_size = size;
_buffer = new T[_size + 1];
_head = 0;
_headMirrorSide = 0;
_tail = 0;
_tailMirrorSide = 0;
}
private bool IsFull()
{
return _tail == _head && _tailMirrorSide != _headMirrorSide;
}
public bool IsEmpty()
{
return _tail == _head && _tailMirrorSide == _headMirrorSide;
}
private void MovePointer(ref int pointer, ref byte mirrorSide)
{
pointer = pointer + 1;
if (pointer == _size)
{
mirrorSide ^= 1;
pointer = 0;
}
}
public void Write(T obj)
{
_buffer[_head] = obj;
if (IsFull())
{
MovePointer(ref _tail, ref _tailMirrorSide);
}
MovePointer(ref _head, ref _headMirrorSide);
}
public T Read()
{
var obj = _buffer[_tail];
_buffer[_tail] = default(T);
MovePointer(ref _tail, ref _tailMirrorSide);
return obj;
}
}编辑:最终的结果是这样的。
public class CircularBuffer<T> where T : class
{
private readonly int _size;
private int _head;
private byte _headMirrorSide;
private int _tail;
private byte _tailMirrorSide;
private readonly T[] _buffer;
private readonly object _lock = new object();
public CircularBuffer() : this(300) { }
public CircularBuffer(int size)
{
_size = size;
_buffer = new T[_size + 1];
_head = 0;
_headMirrorSide = 0;
_tail = 0;
_tailMirrorSide = 0;
}
private bool IsFull()
{
return _tail == _head && _tailMirrorSide != _headMirrorSide;
}
private bool IsEmpty()
{
return _tail == _head && _tailMirrorSide == _headMirrorSide;
}
private void MovePointer(ref int pointer, ref byte mirrorSide)
{
pointer = pointer + 1;
if (pointer == _size)
{
mirrorSide ^= 1;
pointer = 0;
}
}
public void Write(T obj)
{
lock (_lock)
{
_buffer[_head] = obj;
if (IsFull())
{
MovePointer(ref _tail, ref _tailMirrorSide);
}
MovePointer(ref _head, ref _headMirrorSide);
}
}
public T Read()
{
lock (_lock)
{
if (IsEmpty())
{
return null;
}
var obj = _buffer[_tail];
MovePointer(ref _tail, ref _tailMirrorSide);
return obj;
}
}
}发布于 2013-09-28 12:28:35
只要您接触到来自不同线程的数据,就必须同步访问。最简单的方法是lock()指令,它应该放在Read()和Write()方法中。
显然,only()应该有lock(),以避免并发提交到同一个内存单元(因为缓冲区正在从每个编写器中积累数据,而不仅仅是“赢家”)。
Read()也应该有lock(),因为它
在高级水平上,您可以使用单向内存屏障而不是单向锁,但这需要大量的经验。
发布于 2013-09-28 12:24:34
如果有多个线程访问缓冲区,并且所有线程都只读取,则不必使用锁。但是,如果一个或多个线程正在修改数据,则需要一个锁。因此,在您的例子中,答案是明确的是,特别是因为您的Read()方法也会更改数据:缓冲区指针的位置。
https://stackoverflow.com/questions/19066799
复制相似问题