Потоковая безопасность методов утилизации?

Проблема безопасности потоков и Dispose несколько сложна. Поскольку во многих случаях единственное, что любой поток может законно делать с объектом после того, как какой-либо другой поток начал избавляться от него, это попытка его самого удаления, на первый взгляд может показаться, что единственное, что необходимо для обеспечения безопасности потока, - это используйте Interlocked.Exchange для флага disposed, чтобы гарантировать, что попытка Dispose одного потока произойдет, а другой будет молча проигнорирован. Действительно, это хорошая отправная точка, и я думаю, что она должна была быть частью стандартного шаблона Dispose (CompareExchange должен был быть выполнен в методе запечатанной оболочки базового класса, чтобы избежать необходимости для каждого производного класса использовать свой собственный частный класс. убранный флаг). К сожалению, если учесть, что на самом деле делает Dispose, все намного сложнее.

Настоящая цель Dispose - не делать что-то с удаляемым объектом, а скорее очищать другие сущности, на которые этот объект содержит ссылки. Эти сущности могут быть управляемыми объектами, системными объектами или чем-то еще; они могут даже не находиться на том же компьютере, что и удаляемый объект. Чтобы Dispose был потокобезопасным, эти другие сущности позволили бы Dispose очищать их в то же время, когда другие потоки могли бы делать с ними другие вещи. Некоторые объекты могут справиться с таким использованием; другие не могут.

Один особенно неприятный пример: объектам разрешено иметь события с методами RemoveHandler, которые не являются потокобезопасными. Следовательно, любой метод Dispose, который очищает обработчики событий, должен вызываться только из того же потока, что и тот, в котором были созданы подписки.

На странице MSDN здесь никогда прямо не говорится, что методы Dispose не потокобезопасные, но, насколько я понимаю, их код подразумевает, что нет, они не являются потокобезопасными, и при необходимости вы должны учитывать это.

В частности, комментарии в примере кода:

// This class shows how to use a disposable resource.
// The resource is first initialized and passed to
// the constructor, but it could also be
// initialized in the constructor.
// The lifetime of the resource does not 
// exceed the lifetime of this instance.
// This type does not need a finalizer because it does not
// directly create a native resource like a file handle
// or memory in the unmanaged heap.

public class DisposableResource : IDisposable
{

    private Stream _resource;  
    private bool _disposed;

    // The stream passed to the constructor 
    // must be readable and not null.
    public DisposableResource(Stream stream)
    {
        if (stream == null)
            throw new ArgumentNullException("Stream in null.");
        if (!stream.CanRead)
            throw new ArgumentException("Stream must be readable.");

        _resource = stream;

        _disposed = false;
    }

    // Demonstrates using the resource. 
    // It must not be already disposed.
    public void DoSomethingWithResource() {
        if (_disposed)
            throw new ObjectDisposedException("Resource was disposed.");

        // Show the number of bytes.
        int numBytes = (int) _resource.Length;
        Console.WriteLine("Number of bytes: {0}", numBytes.ToString());
    }


    public void Dispose() 
    {
        Dispose(true);

        // Use SupressFinalize in case a subclass
        // of this type implements a finalizer.
        GC.SuppressFinalize(this);      
    }

    protected virtual void Dispose(bool disposing)
    {
        // If you need thread safety, use a lock around these 
        // operations, as well as in your methods that use the resource.
        if (!_disposed)
        {
            if (disposing) {
                if (_resource != null)
                    _resource.Dispose();
                    Console.WriteLine("Object disposed.");
            }

            // Indicate that the instance has been disposed.
            _resource = null;
            _disposed = true;   
        }
    }
}

Я совершенно уверен, что, если не указано иное, метод Dispose() любого класса будет считаться «членом экземпляра» для целей документации, указывающих на безопасность потоков или нет.

Итак, если в документации указано, что члены экземпляра не являются потокобезопасными, то это не обязательно Dispose(), если это специально не отмечено как отличное от остальных.