We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Threading \ Monitor

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*=============================================================================
  16. **
  17. ** Class: Monitor
  18. **
  19. **
  20. ** Purpose: Synchronizes access to a shared resource or region of code in a multi-threaded
  21. **            program.
  22. **
  23. **
  24. =============================================================================*/
  27. namespace System.Threading
  28. {
  29.    
  30.     using System;
  31.     using System.Security.Permissions;
  32.     using System.Runtime.Remoting;
  33.     using System.Threading;
  34.     using System.Runtime.CompilerServices;
  35.     using System.Runtime.ConstrainedExecution;
  36.    
  37.     [HostProtection(Synchronization = true, ExternalThreading = true)]
  38.     [System.Runtime.InteropServices.ComVisible(true)]
  39.     public static class Monitor
  40.     {
  41. /*=========================================================================
  42.         ** Obtain the monitor lock of obj. Will block if another thread holds the lock
  43.         ** Will not block if the current thread holds the lock,
  44.         ** however the caller must ensure that the same number of Exit
  45.         ** calls are made as there were Enter calls.
  46.         **
  47.         ** Exceptions: ArgumentNullException if object is null.
  48.         =========================================================================*/       
  49.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  50.         public static extern void Enter(object obj);
  51.        
  52.         // This should be made public in a future version.
  53.         // Use a ref bool instead of out to ensure that unverifiable code must
  54.         // initialize this value to something. If we used out, the value
  55.         // could be uninitialized if we threw an exception in our prolog.
  56.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  57.         static internal extern void ReliableEnter(object obj, ref bool tookLock);
  58.        
  59.        
  60. /*=========================================================================
  61.         ** Release the monitor lock. If one or more threads are waiting to acquire the
  62.         ** lock, and the current thread has executed as many Exits as
  63.         ** Enters, one of the threads will be unblocked and allowed to proceed.
  64.         **
  65.         ** Exceptions: ArgumentNullException if object is null.
  66.         **            SynchronizationLockException if the current thread does not
  67.         **            own the lock.
  68.         =========================================================================*/       
  69.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  70.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  71.         public static extern void Exit(object obj);
  72.        
  73. /*=========================================================================
  74.         ** Similar to Enter, but will never block. That is, if the current thread can
  75.         ** acquire the monitor lock without blocking, it will do so and TRUE will
  76.         ** be returned. Otherwise FALSE will be returned.
  77.         **
  78.         ** Exceptions: ArgumentNullException if object is null.
  79.         =========================================================================*/       
  80.         public static bool TryEnter(object obj)
  81.         {
  82.             return TryEnterTimeout(obj, 0);
  83.         }
  84.        
  85. /*=========================================================================
  86.         ** Version of TryEnter that will block, but only up to a timeout period
  87.         ** expressed in milliseconds. If timeout == Timeout.Infinite the method
  88.         ** becomes equivalent to Enter.
  89.         **
  90.         ** Exceptions: ArgumentNullException if object is null.
  91.         **            ArgumentException if timeout < 0.
  92.         =========================================================================*/       
  93.         public static bool TryEnter(object obj, int millisecondsTimeout)
  94.         {
  95.             return TryEnterTimeout(obj, millisecondsTimeout);
  96.         }
  97.        
  98.         public static bool TryEnter(object obj, TimeSpan timeout)
  99.         {
  100.             long tm = (long)timeout.TotalMilliseconds;
  101.             if (tm < -1 || tm > (long)Int32.MaxValue)
  102.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  103.            
  104.             return TryEnterTimeout(obj, (int)tm);
  105.         }
  106.        
  107.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  108.         private static extern bool TryEnterTimeout(object obj, int timeout);
  109.        
  110. /*========================================================================
  111. ** Waits for notification from the object (via a Pulse/PulseAll).
  112. ** timeout indicates how long to wait before the method returns.
  113. ** This method acquires the monitor waithandle for the object
  114. ** If this thread holds the monitor lock for the object, it releases it.
  115. ** On exit from the method, it obtains the monitor lock back.
  116. ** If exitContext is true then the synchronization domain for the context
  117. ** (if in a synchronized context) is exited before the wait and reacquired
  118. **
  119.         ** Exceptions: ArgumentNullException if object is null.
  120. ========================================================================*/       
  121.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  122.         private static extern bool ObjWait(bool exitContext, int millisecondsTimeout, object obj);
  123.        
  124.         public static bool Wait(object obj, int millisecondsTimeout, bool exitContext)
  125.         {
  126.             if (obj == null)
  127.                 throw (new ArgumentNullException("obj"));
  128.             return ObjWait(exitContext, millisecondsTimeout, obj);
  129.         }
  130.        
  131.         public static bool Wait(object obj, TimeSpan timeout, bool exitContext)
  132.         {
  133.             long tm = (long)timeout.TotalMilliseconds;
  134.             if (tm < -1 || tm > (long)Int32.MaxValue)
  135.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  136.            
  137.             return Wait(obj, (int)tm, exitContext);
  138.         }
  139.        
  140.         public static bool Wait(object obj, int millisecondsTimeout)
  141.         {
  142.             return Wait(obj, millisecondsTimeout, false);
  143.         }
  144.        
  145.         public static bool Wait(object obj, TimeSpan timeout)
  146.         {
  147.             long tm = (long)timeout.TotalMilliseconds;
  148.             if (tm < -1 || tm > (long)Int32.MaxValue)
  149.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  150.            
  151.             return Wait(obj, (int)tm, false);
  152.         }
  153.        
  154.         public static bool Wait(object obj)
  155.         {
  156.             return Wait(obj, Timeout.Infinite, false);
  157.         }
  158.        
  159. /*========================================================================
  160.         ** Sends a notification to a single waiting object.
  161.         * Exceptions: SynchronizationLockException if this method is not called inside
  162.         * a synchronized block of code.
  163.         ========================================================================*/       
  164.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  165.         private static extern void ObjPulse(object obj);
  166.        
  167.         public static void Pulse(object obj)
  168.         {
  169.             if (obj == null) {
  170.                 throw new ArgumentNullException("obj");
  171.             }
  172.            
  173.             ObjPulse(obj);
  174.         }
  175. /*========================================================================
  176.         ** Sends a notification to all waiting objects.
  177.         ========================================================================*/       
  178.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  179.         private static extern void ObjPulseAll(object obj);
  180.        
  181.         public static void PulseAll(object obj)
  182.         {
  183.             if (obj == null) {
  184.                 throw new ArgumentNullException("obj");
  185.             }
  186.            
  187.             ObjPulseAll(obj);
  188.         }
  189.     }
  190. }

Developer Fusion