/// <summary>
/// Creates cache enabled Slim lock with policy.
/// </summary>
/// <param name="policy"><see cref="LockRecursionPolicy"/> that specifies whether a lock can be entered multiple times by the same thread.</param>
public CacheEnabledSlimLock(LockRecursionPolicy policy)
: base(policy)
{
this.cachedLRB = new LockedReadBlock(this.rwLock);
this.cachedLWB = new LockedWriteBlock(this.rwLock);
this.cachedLURB = new LockedUpgradeableReadBlock(this.rwLock);
}
/// <summary>
///
/// </summary>
/// <param name="recursionPolicy">
/// This parameter is forwarded to the constructor of the backing
/// <see cref="ReaderWriterLockSlim"/> object
/// </param>
/// <param name="disableDispatcherProcessingWhenNoRecursion">
/// Specifies whether Dispatcher processing should be disabled when
/// <paramref name="recursionPolicy"/> is <see cref="LockRecursionPolicy.NoRecursion"/>.
/// It is preferable to disable Dispatcher processing to prevent reentrancy problems.
/// If Dispatcher processing is disabled, the critical action that is performed while
/// the lock is held cannot in turn depend on dispatcher processing - for e.g., any
/// actions involving UI updates would throw an exception. The default value for this
/// parameter is true -i.e., we disable Dispatcher processing by default when
/// <see cref="LockRecursionPolicy.NoRecursion"/> is specified.
///
/// This parameter is ignored when <see cref="LockRecursionPolicy.SupportsRecursion"/>
/// is specified.
/// </param>
internal ReaderWriterLockSlimWrapper(
LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion,
bool disableDispatcherProcessingWhenNoRecursion = true)
{
_lockRecursionPolicy = recursionPolicy;
_disableDispatcherProcessingWhenNoRecursion = disableDispatcherProcessingWhenNoRecursion;
_rwLock = new ReaderWriterLockSlim(_lockRecursionPolicy);
_disposed = false;
// Suppress finalization of this object.
//
// This ensures that the lock is usable within finalizers
// of other objects that have an instance of this type and
// use it for locking there.
//
// It would be the responsibility of caller to explicitly
// dispose this object. If an explicit call to Dispose() fails,
// say because the lock is held at that time by another thread,
// we will re-enable finalization and try to cleanup again when
// Dispose is called from within the finalizer.
//
// This can create the potential for this object to be
// never finalized. This can happen if the caller forgets
// to call Dispose() explicitly. In that case, the backing
// ReaderWriterLockSlim object will still get disposed properly
// when its finalizer runs.
GC.SuppressFinalize(this);
}
/// <summary>
/// Creates RockLock.
/// </summary>
/// <param name="recursionPolicy">Recursion policy.</param>
public RockLock(LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
{
this.rwLock = new ReaderWriterLockSlim(recursionPolicy);
this.readLock = new ReadLock(this.rwLock);
this.writeLock = new WriteLock(this.rwLock);
}
public GuardedReaderWriterLock(LockRecursionPolicy recursionPolicy)
{
_lock = new ReaderWriterLockSlim(recursionPolicy);
_readGuard = new AutoGuard(_lock, false);
_writeGuard = new AutoGuard(_lock, true);
_upgradeGuard = new UpgradeGuard(_lock);
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
if (recursionPolicy == LockRecursionPolicy.SupportsRecursion)
{
this.fIsReentrant = true;
}
this.InitializeThreadCounts();
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
if (recursionPolicy == LockRecursionPolicy.SupportsRecursion)
{
_fIsReentrant = true;
}
InitializeThreadCounts();
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
this.recursionPolicy = recursionPolicy;
if (recursionPolicy != 0)
{
throw new NotImplementedException("recursionPolicy != NoRecursion not currently implemented");
}
}
internal SlimLockWrapper(LockRecursionPolicy policy)
{
#if NET40
_rwsObject = new ReaderWriterLockSlim(policy);
#else
_rwsObject = new ReaderWriterLock();
#endif
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
this.recursionPolicy = recursionPolicy;
if (recursionPolicy != LockRecursionPolicy.NoRecursion)
{
//reader_locks = new Dictionary<int,int> ();
throw new NotImplementedException("recursionPolicy != NoRecursion not currently implemented");
}
}
/// <summary>
/// Initializes a new instance of <see cref="IocContainer"/> with a parent.
/// </summary>
/// <param name="parent">The parent container.</param>
/// <param name="allowRecursiveResolution">
/// If true, recursive calls to Resolve or GetInstance overloads will be allowed.
/// </param>
/// <remarks>
/// If a service cannot be found in this container, the parent is checked.
///
/// Recursive activations may cause a <see cref="StackOverflowException"/> if it
/// triggers resolution of co-dependent types.
///
/// Care must be taken when enabling this feature. Consider the code:
/// <code>
/// class ExampleA : IExampleA
/// {
/// private IExampleB b;
///
/// public ExampleA(IServiceLocator ioc)
/// {
/// b = ioc.GetInstance<IExampleB>();
/// }
/// }
///
/// class ExampleB : IExampleB
/// {
/// private IExampleA a;
///
/// public ExampleB(IServiceLocator ioc)
/// {
/// a = ioc.GetInstance<IExampleA>();
/// }
/// }
///
/// void Main()
/// {
/// var ioc = new IocContainer(<paramref name="allowRecursiveResolution"/>: false);
/// ioc.Bind<IServiceLocator>(() => ioc);
/// ioc.Bind<IExampleA, ExampleA>();
/// ioc.Bind<IExampleB, ExampleB>();
///
/// IExampleA a = ioc.Resolve<IExampleA>();
/// }
/// </code>
///
/// If <paramref name="allowRecursiveResolution"/> were true, an uncatchable
/// <see cref="StackOverflowException"/> would be raised because both ExampleA and
/// ExampleB try to resolve each other from their constructors.
/// </remarks>
public IocContainer(IServiceLocator parent, bool allowRecursiveResolution)
{
_parentContainer = parent;
LockRecursionPolicy recursionPolicy = allowRecursiveResolution
? LockRecursionPolicy.SupportsRecursion
: LockRecursionPolicy.NoRecursion;
_lock = new ReaderWriterLockSlim(recursionPolicy);
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
if (recursionPolicy == LockRecursionPolicy.SupportsRecursion)
{
_fIsReentrant = true;
}
InitializeThreadCounts();
_fNoWaiters = true;
_lockID = Interlocked.Increment(ref s_nextLockID);
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
RecursionPolicy = recursionPolicy;
_noRecursion = recursionPolicy == LockRecursionPolicy.NoRecursion;
// ---
_id = Interlocked.Increment(ref _idPool);
_fastStateCache = new ThreadLockState[64];
_upgradableTaken = new AtomicBoolean();
_upgradableEvent = new ManualResetEventSlim(true);
_writerDoneEvent = new ManualResetEventSlim(true);
_readerDoneEvent = new ManualResetEventSlim(true);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="recursionPolicy">递归策略 默认是不支持递归</param>
public MyReaderWriterLockSlim(MyLockRecursionPolicy recursionPolicy)
{
LockRecursionPolicy policy = LockRecursionPolicy.NoRecursion;
switch (recursionPolicy)
{
case MyLockRecursionPolicy.NoRecursion:
policy = LockRecursionPolicy.NoRecursion;
break;
case MyLockRecursionPolicy.SupportsRecursion:
policy = LockRecursionPolicy.SupportsRecursion;
break;
default:
break;
}
locker = new ReaderWriterLockSlim(policy);
}
public static void InvalidExits(LockRecursionPolicy policy)
{
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim(policy))
{
Assert.Throws <SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws <SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
Assert.Throws <SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.EnterReadLock();
Assert.Throws <SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
Assert.Throws <SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.ExitReadLock();
rwls.EnterUpgradeableReadLock();
Assert.Throws <SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws <SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.ExitUpgradeableReadLock();
rwls.EnterWriteLock();
Assert.Throws <SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws <SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
rwls.ExitWriteLock();
using (Barrier barrier = new Barrier(2))
{
Task t = Task.Factory.StartNew(() =>
{
rwls.EnterWriteLock();
barrier.SignalAndWait();
barrier.SignalAndWait();
rwls.ExitWriteLock();
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
barrier.SignalAndWait();
Assert.Throws <SynchronizationLockException>(() => rwls.ExitWriteLock());
barrier.SignalAndWait();
t.GetAwaiter().GetResult();
}
}
}
/// <summary>
/// Initializes a new instance of the ConcurrentList class.
/// </summary>
/// <param name="recursionPolicy">One of the enumeration values that specifies the lock recursion policy.</param>
/// <param name="collection">The collection of elements used to initialize the thread-safe collection.</param>
/// <param name="useSource">true if set the collection as source directly instead of copying; otherwise, false.</param>
internal SynchronizedList(LockRecursionPolicy recursionPolicy, IEnumerable <T> collection = null, bool useSource = false)
{
slim = new ReaderWriterLockSlim(recursionPolicy);
if (collection is null)
{
list = new List <T>();
return;
}
if (useSource)
{
if (collection is List <T> l)
{
list = l;
return;
}
else if (collection is SynchronizedList <T> sl)
{
list = sl.list;
return;
}
}
try
{
list = new List <T>(collection);
}
catch (NullReferenceException)
{
list = new List <T>(collection);
}
catch (InvalidOperationException)
{
list = new List <T>(collection);
}
}
public ReaderWriterLockedObject(T value, LockRecursionPolicy policy)
{
_value = value;
_lockContext = new ReaderWriterLockContext(policy);
}
public PortableReaderWriterLock(LockRecursionPolicy lockRecursionPolicy)
{
// Lock
_readerWriterLock = new ReaderWriterLockSlim(lockRecursionPolicy);
}
/// <summary>
/// Creates a new <see cref="EnhancedReaderWriterLock"/> using a <seealso cref="LockRecursionPolicy"/>.
/// </summary>
/// <param name="policy">the policy</param>
public EnhancedReaderWriterLock(LockRecursionPolicy policy)
{
_rwLock = new ReaderWriterLockSlim(policy);
}
public KeyLockManager(LockRecursionPolicy policy)
{
_policy = policy;
_keyLockTable = new Dictionary <TKey, SlimLockWrapper>();
}
/// <summary>
/// 提供锁定递归策略，初始化一个 <see cref="System.LockSlim"/> 类的新实例。
/// </summary>
/// <param name="recursionPolicy">锁定递归策略。</param>
public LockSlim(LockRecursionPolicy recursionPolicy)
{
_Slim = new ReaderWriterLockSlim(recursionPolicy);
}
public ReaderWriterLockSlimOf(LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
{
@lock = new ReaderWriterLockSlim(recursionPolicy);
}
public ReadWriteLock(LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
: base(recursionPolicy)
{
_writeGuard = new WriteScopeGuard(this);
_readGuard = new ReadScopeGuard(this);
}
// The special constructor is used to deserialize values.
public ReaderWriterLockStrategy(SerializationInfo info, StreamingContext context)
{
_lockRecursionPolicy = (LockRecursionPolicy)info.GetValue("_lockRecursionPolicy", typeof(LockRecursionPolicy));
_lock = new ReaderWriterLockSlim(_lockRecursionPolicy);
}
public Lock(bool isThreadSafe, LockRecursionPolicy recursionPolicy)
{
IsThreadSafe = isThreadSafe;
if (isThreadSafe)
_lock = new ReaderWriterLockSlim(recursionPolicy);
}
/// <summary>
/// Constructs an instance on the ReaderWriterSlimResourceLock with the desired recursion policy.
/// </summary>
public ReaderWriterSlimResourceLock(LockRecursionPolicy recursionPolicy)
: base(ResourceLockOptions.AcquiringThreadMustRelease |
((recursionPolicy == LockRecursionPolicy.SupportsRecursion) ? ResourceLockOptions.SupportsRecursion : 0)) {
m_lock = new ReaderWriterLockSlim(recursionPolicy);
}
public LockEcritureEtLectureFake(
LockRecursionPolicy recursionStatut)
{
}
/// <summary>
/// 提供锁定递归策略，初始化一个 <see cref="LockSlim"/> 类的新实例。
/// </summary>
/// <param name="recursionPolicy">锁定递归策略。</param>
public LockSlim(LockRecursionPolicy recursionPolicy)
{
_Slim = new ReaderWriterLockSlim(recursionPolicy);
}
public ReaderWriterLockSlimEx(LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
: this(new ReaderWriterLockSlim(recursionPolicy))
{ }
public ReaderWriterLockSlimEx(string name, LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
: this(name, new ReaderWriterLockSlim(recursionPolicy))
{ }
public Locker(TObjectLocked objectLocked, LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
{
this.objectLocked = objectLocked;
}
public ReaderWriterLockSlim (LockRecursionPolicy recursionPolicy)
{
this.recursionPolicy = recursionPolicy;
}
public TwoStageRWLock(LockRecursionPolicy policy = LockRecursionPolicy.NoRecursion)
{
_lock = new ReaderWriterLockSlim(policy);
}
public ScopedReaderWriterLock(
LockRecursionPolicy recursionPolicy)
: base(recursionPolicy)
{
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
this.recursionPolicy = recursionPolicy;
if (recursionPolicy != LockRecursionPolicy.NoRecursion){
//reader_locks = new Dictionary<int,int> ();
throw new NotImplementedException ("recursionPolicy != NoRecursion not currently implemented");
}
}
public static IReaderWriterLock Create(string lockName, int timeOut, LockRecursionPolicy recursionPolicy)
{
return new ReaderWriterLock(lockName, timeOut, recursionPolicy);
}
public ReaderWriterLockWrap(LockRecursionPolicy lrp)
: base(lrp)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SyncLock"/> class.
/// </summary>
/// <param name="recursionPolicy">The recursion policy.</param>
public SyncLock(LockRecursionPolicy recursionPolicy) : this(new ReaderWriterLockSlim(recursionPolicy))
{
}
public static void InvalidExits(LockRecursionPolicy policy)
{
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim(policy))
{
Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.EnterReadLock();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.ExitReadLock();
rwls.EnterUpgradeableReadLock();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.ExitUpgradeableReadLock();
rwls.EnterWriteLock();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
rwls.ExitWriteLock();
using (Barrier barrier = new Barrier(2))
{
Task t = Task.Factory.StartNew(() =>
{
rwls.EnterWriteLock();
barrier.SignalAndWait();
barrier.SignalAndWait();
rwls.ExitWriteLock();
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
barrier.SignalAndWait();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
barrier.SignalAndWait();
t.GetAwaiter().GetResult();
}
}
}
// The special constructor is used to deserialize values.
public ReaderWriterLockStrategy(SerializationInfo info, StreamingContext context)
{
_lockRecursionPolicy = (LockRecursionPolicy)info.GetValue("_lockRecursionPolicy", typeof(LockRecursionPolicy));
_lock = new ReaderWriterLockSlim(_lockRecursionPolicy);
}
/// <summary>
/// Creates Slim lock with policy.
/// </summary>
/// <param name="policy"><see cref="LockRecursionPolicy"/> that specifies whether a lock can be entered multiple times by the same thread.</param>
public SlimLock(LockRecursionPolicy policy)
{
this.rwLock = new ReaderWriterLockSlim(policy);
}
public EasyReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
: base(recursionPolicy)
{
}
public NamedReaderWriterLockSlim(string name, LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
: base(recursionPolicy)
{
this.name = name;
}
public ReaderWriterLockStrategy(LockRecursionPolicy recursionPolicy)
{
_lockRecursionPolicy = recursionPolicy;
_lock = new ReaderWriterLockSlim(recursionPolicy);
}
public ReaderWriterLockStrategy(LockRecursionPolicy recursionPolicy)
{
_lockRecursionPolicy = recursionPolicy;
_lock = new ReaderWriterLockSlim(recursionPolicy);
}
public DisposableReaderWriterLock(LockRecursionPolicy recursionPolicy)
{
this.lockSlim = new ReaderWriterLockSlim(recursionPolicy);
}
public ReaderWriterLockSlim (LockRecursionPolicy recursionPolicy)
{
this.recursionPolicy = recursionPolicy;
this.noRecursion = recursionPolicy == LockRecursionPolicy.NoRecursion;
}
public ReaderWriterLockSlimWrapper(LockRecursionPolicy recursionPolicy)
{
locker = new ReaderWriterLockSlim(recursionPolicy);
}
public static ReaderWriterLockSlim GetLockInstance(LockRecursionPolicy recursionPolicy)
{
return(new ReaderWriterLockSlim(recursionPolicy));
}
public static ReaderWriterLockSlim GetLockInstance(LockRecursionPolicy recursionPolicy)
{
return new ReaderWriterLockSlim(recursionPolicy);
}
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
if (recursionPolicy == LockRecursionPolicy.SupportsRecursion)
{
fIsReentrant = true;
}
InitializeThreadCounts();
fNoWaiters = true;
lockID = Interlocked.Increment(ref s_nextLockID);
}
public ReaderWriterLockSlim( LockRecursionPolicy recursionPolocy ) { }
public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
{
}
internal ReaderWriterLock(string lockName, int timeOut, LockRecursionPolicy recursionPolicy)
{
this.lockName = lockName;
this.lockSlim = new ReaderWriterLockSlim(recursionPolicy);
this.TimeOut = timeOut;
}
