4

我想实现一个线程安全列表，但必须确保整个操作块的线程安全，而不仅仅是单个操作（例如添加、删除等）。用例应如下所示：

list.Lock();

list.Add(sth);
list.RemoveAt(4);

list.Unlock();

我希望列表要求锁定任何操作。例如：

list.Add(sth);

在没有事先锁定的情况下调用应该会导致异常。这就是我不使用该lock()语句的原因 - 锁定检查对于此解决方案至关重要。

使用 Monitor 实现这样的列表并不难——但只有在想要检查列表是否被锁定之前。我想到了以下场景：

// Inside list class

private object lockObject;
private bool locked;

public void Lock()
{
    Monitor.Enter(lockObject);
    locked = true;
}

public void Unlock()
{
    Monitor.Exit(lockObject);
    locked = false;
}

不幸的是，这段代码很容易出现竞争条件——无论locked是在进入或离开临界区之前还是之后设置。

另一种方法涉及到使用 TryEnter，但是这种方法实际上是在没有获得锁的情况下进入临界区，这也可能导致竞争条件。

我应该如何实现这个机制以保证线程安全，以及如何在检查列表是否被锁定时避免竞争条件？

4

4 回答 4

3

我正在考虑类似于 Builder 模式的东西。

示例用法：

list
    .do() // mandatory initial statement.
          // Doesn't acquire a lock - it just builds a transaction object

    .add(42) // Add an operation to the transaction object.
             // Call would be illegal without performing do() before

    .removeAt(0) // Another added operation

    .end(); // Acquire the lock, perform the specified changes, release the lock.

要执行的锁获取end()可以是一个简单的调用sync {...}- 没有可能的竞争条件。

于 2013-06-11T06:58:27.373 回答
3

您可以让您的类负责锁定，并且只公开一个接受Action消费者指定的方法：

public class LockedCollection
{
    private class CollectionImpl : ICollection<int>
    {
       //Collection methods
    }

    private sealed class CollectionWrapper : ICollection<int>, IDisposable
    {
       public CollectionWrapper(CollectionImpl inner)
       {
           _inner = inner;
       }
       private CollectionImpl _inner
       //Collection methods all just wrapping calls to inner
       public void Dispose()
       {
          _inner = null;
       }
    }


    private CollectionImpl _instance - new CollectionImpl();
    private object _lock = new object();

    public void DoStuff(Action<ICollection<int>> task)
    {
        lock(_lock)
        {
            using(var wrapper = new CollectionWrapper(_instance))
            {
                task(wrapper);
            }
        }
    }
}

消费者可以在内部进行任何他们喜欢的操作序列task，并且您知道锁已被占用 - 因为您自己占用了它。

于 2013-06-11T07:02:10.950 回答
1

如果您为用作锁的对象提供 getter，则可以使用标准锁定机制。虽然我不认为这是一个优雅的解决方案，但它肯定会成功。

void performOpertations(TSList list) {
  lock(list.getLock()) {
    list.add(obj);
    list.remove(obj2);
    // do your stuff
  }
}

由于 C# 同步块是可重入的，因此您将能够像示例add()或remove()示例中那样调用列表的内部同步方法。

另一种解决方案是使用访问者模式并让访问者操作被同步块包围。

于 2013-06-11T07:02:27.560 回答
1

我看不出有任何理由不使用ReaderWriterLockSlim：

class MyThreadSafeList<T>
{
    private readonly List<T> internalList = new List<T>();
    private readonly ReaderWriterLockSlim lockSlim = new ReaderWriterLockSlim();

    public void EnterReadLock()
    {
        lockSlim.EnterReadLock();
    }

    public void ExitReadLock()
    {
        lockSlim.ExitReadLock();
    }

    public void EnterWriteLock()
    {
        lockSlim.EnterWriteLock();
    }

    public void ExitWriteLock()
    {
        lockSlim.ExitWriteLock();
    }

    public void Add(T item)
    {
        if (!lockSlim.IsWriteLockHeld)
        {
            throw new InvalidOperationException();
        }

        internalList.Add(item);
    }

    public void Remove(T item)
    {
        if (!lockSlim.IsWriteLockHeld)
        {
            throw new InvalidOperationException();
        }

        internalList.Remove(item);
    }

    public T this[int index]
    {
        get
        {
            if (!lockSlim.IsReadLockHeld)
            {
                throw new InvalidOperationException();
            }

            return internalList[index];
        }
        set
        {
            if (!lockSlim.IsWriteLockHeld)
            {
                throw new InvalidOperationException();
            }

            internalList[index] = value;
        }
    }
}
于 2013-06-11T07:29:06.537 回答