116 lines
4.4 KiB
C#
116 lines
4.4 KiB
C#
// Licensed to the .NET Foundation under one or more agreements.
|
|
// The .NET Foundation licenses this file to you under the MIT license.
|
|
// See the LICENSE file in the project root for more information.
|
|
|
|
using System.Diagnostics;
|
|
|
|
namespace System.Threading
|
|
{
|
|
/// <summary>
|
|
/// Provides callbacks to objects whose lifetime is managed by <see cref="DeferredDisposableLifetime{T}"/>.
|
|
/// </summary>
|
|
internal interface IDeferredDisposable
|
|
{
|
|
/// <summary>
|
|
/// Called when the object's refcount reaches zero.
|
|
/// </summary>
|
|
/// <param name="disposed">
|
|
/// Indicates whether the object has been disposed.
|
|
/// </param>
|
|
/// <remarks>
|
|
/// If the refount reaches zero before the object is disposed, this method will be called with
|
|
/// <paramref name="disposed"/> set to false. If the object is then disposed, this method will be
|
|
/// called again, with <paramref name="disposed"/> set to true. If the refcount reaches zero
|
|
/// after the object has already been disposed, this will be called a single time, with
|
|
/// <paramref name="disposed"/> set to true.
|
|
/// </remarks>
|
|
void OnFinalRelease(bool disposed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Manages the lifetime of an object which implements IDisposable, but which must defer the actual
|
|
/// cleanup of state until all existing uses of the object are complete.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of object whose lifetime will be managed.</typeparam>
|
|
/// <remarks>
|
|
/// This type maintains a reference count, and tracks whether the object has been disposed. When
|
|
/// Callbacks are made to <see cref="IDeferredDisposable.OnFinalRelease(bool)"/> when the refcount
|
|
/// reaches zero. Objects that need to defer cleanup until they have been disposed *and* they have
|
|
/// no more references can do so in <see cref="IDeferredDisposable.OnFinalRelease(bool)"/> when
|
|
/// 'disposed' is true.
|
|
/// </remarks>
|
|
internal struct DeferredDisposableLifetime<T> where T : class, IDeferredDisposable
|
|
{
|
|
//
|
|
// _count is positive until Dispose is called, after which it's (-1 - refcount).
|
|
//
|
|
private int _count;
|
|
|
|
public bool AddRef(T obj)
|
|
{
|
|
while (true)
|
|
{
|
|
int oldCount = Volatile.Read(ref _count);
|
|
|
|
// Have we been disposed?
|
|
if (oldCount < 0)
|
|
throw new ObjectDisposedException(typeof(T).ToString());
|
|
|
|
int newCount = checked(oldCount + 1);
|
|
|
|
if (Interlocked.CompareExchange(ref _count, newCount, oldCount) == oldCount)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public void Release(T obj)
|
|
{
|
|
while (true)
|
|
{
|
|
int oldCount = Volatile.Read(ref _count);
|
|
if (oldCount > 0)
|
|
{
|
|
// We haven't been disposed. Decrement _count.
|
|
int newCount = oldCount - 1;
|
|
if (Interlocked.CompareExchange(ref _count, newCount, oldCount) == oldCount)
|
|
{
|
|
if (newCount == 0)
|
|
obj.OnFinalRelease(disposed: false);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.Assert(oldCount != 0 && oldCount != -1);
|
|
|
|
// We've been disposed. Increment _count.
|
|
int newCount = oldCount + 1;
|
|
if (Interlocked.CompareExchange(ref _count, newCount, oldCount) == oldCount)
|
|
{
|
|
if (newCount == -1)
|
|
obj.OnFinalRelease(disposed: true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Dispose(T obj)
|
|
{
|
|
while (true)
|
|
{
|
|
int oldCount = Volatile.Read(ref _count);
|
|
if (oldCount < 0)
|
|
return; // already disposed
|
|
|
|
int newCount = -1 - oldCount;
|
|
if (Interlocked.CompareExchange(ref _count, newCount, oldCount) == oldCount)
|
|
{
|
|
if (newCount == -1)
|
|
obj.OnFinalRelease(disposed: true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |