首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >CircularBuffer,我需要加锁吗?

问CircularBuffer,我需要加锁吗?
EN

Stack Overflow用户
提问于 2013-09-28 12:09:36
回答 2查看 285关注 0票数 1

我对整个循环/循环缓冲思维方式都很陌生。我阅读了一些关于理论上应该如何工作的文章,并给出了这个代码示例。在我的场景中,我将有多个线程写入和一个线程从缓冲区读取。

我是否需要向写方法添加一个锁?

提前感谢!

代码语言:javascript
复制
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;
    }
}

编辑:最终的结果是这样的。

代码语言:javascript
复制
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;
        }
    }
}
EN

回答 2

Stack Overflow用户

回答已采纳

发布于 2013-09-28 12:28:35

只要您接触到来自不同线程的数据,就必须同步访问。最简单的方法是lock()指令,它应该放在Read()和Write()方法中。

显然,only()应该有lock(),以避免并发提交到同一个内存单元(因为缓冲区正在从每个编写器中积累数据,而不仅仅是“赢家”)。

Read()也应该有lock(),因为它

  • 修改与写()相同的内部成员
  • 可能会受到编译器优化以及运行时指令重新排序的影响(因为计算效果相同,但是线程间的交互可能会被破坏)。

在高级水平上,您可以使用单向内存屏障而不是单向锁,但这需要大量的经验。

票数 1
EN

Stack Overflow用户

发布于 2013-09-28 12:24:34

如果有多个线程访问缓冲区,并且所有线程都只读取,则不必使用锁。但是,如果一个或多个线程正在修改数据,则需要一个锁。因此,在您的例子中,答案是明确的是,特别是因为您的Read()方法也会更改数据:缓冲区指针的位置。

票数 1
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/19066799

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档