System.Threading.Monitor.Exit(object)

Here are the examples of the csharp api System.Threading.Monitor.Exit(object) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

802 Examples 7

19 Source : ServerHandler.cs
with MIT License
from azist

private ResponseMsg doWork(RequestMsg request)
                {
                   var contract = request.Contract;//this throws when contract can't be found
                   var server = getServerImplementer(request.ServerTransport.ServerEndpoint, contract);//throws when no implementor match found

                   if (server.AuthenticationSupport)
                        interpretAuthenticationHeader(request);


                   //Authorizes user to the whole server contract and implementing clreplaced
                   Permission.AuthorizeAndGuardAction(App.SecurityManager, server.Contract);
                   Permission.AuthorizeAndGuardAction(App.SecurityManager, server.Implementation);

                   serverImplementer.mapping mapped = server.SpecToMethodInfos(request.Method);


                   Permission.AuthorizeAndGuardAction(App.SecurityManager, mapped.miContract);
                   Permission.AuthorizeAndGuardAction(App.SecurityManager, mapped.miImplementation);


                   Guid? checkedOutID;
                   bool lockTaken;
                   var instance = getServerInstance(server, request, out checkedOutID, out lockTaken); //throws when instance expired or cant be locked
                   try
                   {
                       Guid? instanceID = null;
                       bool isCtor = false;
                       bool isDctor = false;

                       if (server.InstanceMode == ServerInstanceMode.Stateful ||
                           server.InstanceMode == ServerInstanceMode.AutoConstructedStateful)
                       {
                          instanceID = request.RemoteInstance;
                          isCtor = Attribute.IsDefined(mapped.miContract, typeof(ConstructorAttribute));
                          isDctor= Attribute.IsDefined(mapped.miContract, typeof(DestructorAttribute));


                          if (isCtor && isDctor)
                            throw new ServerMethodInvocationException(StringConsts.GLUE_AMBIGUOUS_CTOR_DCTOR_DEFINITION_ERROR
                                                                                  .Args( contract.FullName, request.MethodName));

                          if (server.InstanceMode != ServerInstanceMode.AutoConstructedStateful &&
                              !instanceID.HasValue &&
                              !isCtor)
                            throw new ServerMethodInvocationException(StringConsts.GLUE_NO_SERVER_INSTANCE_ERROR
                                                                                  .Args( contract.FullName, request.MethodName));
                       }

                       //========================================================================================================
                       object result;
                       try
                       {
                            var any = request as RequestAnyMsg;
                            if (any!=null)
                              result = mapped.miContract.Invoke(instance, any.Arguments); //do actual contract-implementing method work
                            else
                            {
                             //call functor using typed RequestMsg derivative
                             if (mapped.fBody==null)
                              throw new ServerMethodInvocationException(StringConsts.GLUE_NO_ARGS_MARSHAL_LAMBDA_ERROR
                                                                                  .Args( contract.FullName, request.MethodName));
                             result = mapped.fBody(instance, request); //do actual contract-implementing method work via Lambda
                            }
                       }
                       catch(Exception bodyError)
                       {
                            Exception err = bodyError;
                            if (err is TargetInvocationException)//unwrap the inner error which is wrapped by Invoke()
                              if (err.InnerException!=null) err = err.InnerException;

                            throw new ServerMethodInvocationException(StringConsts.GLUE_SERVER_CONTRACT_METHOD_INVOCATION_ERROR
                                                                                  .Args(contract.FullName, request.MethodName, err.ToMessageWithType()),
                                                                      err);
                       }
                       //========================================================================================================

                       if (server.InstanceMode == ServerInstanceMode.Stateful ||
                           server.InstanceMode == ServerInstanceMode.AutoConstructedStateful)
                       {
                           if (isCtor || (server.InstanceMode == ServerInstanceMode.AutoConstructedStateful && !isDctor && !instanceID.HasValue))
                           {
                              instanceID = Guid.NewGuid();
                              App.ObjectStore.CheckIn(instanceID.Value, instance, server.InstanceTimeoutMs);
                           }
                           else
                           if (isDctor)
                           {
                             if (instanceID.HasValue)
                             {
                               App.ObjectStore.Delete(instanceID.Value);
                               instanceID = null;
                               checkedOutID = null;
                             }
                           }
                       }


                       if (request.OneWay) return null;

                       var response = new ResponseMsg(request.RequestID, instanceID, result);
                       response.__SetBindingSpecificContext(request);
                       return response;
                   }
                   finally
                   {
                     if (lockTaken)
                        Monitor.Exit(instance);
                     if (checkedOutID.HasValue)
                        App.ObjectStore.CheckIn(checkedOutID.Value, server.InstanceTimeoutMs);
                   }
                }

19 Source : KeyedMonitor.cs
with MIT License
from azist

public bool Exit(TKey key)
    {
      var bucket = getBucket(key);
      _slot _lock;
      lock (bucket)
      {
        if (!bucket.TryGetValue(key, out _lock)) return false;
        Monitor.Exit(_lock);
        _lock.RefCount--;
        if (_lock.RefCount==0)
          bucket.Remove(key);
      }
      return true;
    }

19 Source : Metabank.cs
with MIT License
from azist

internal Configuration GetConfigFromExistingFile(string path)
      {
        var session = obtainSession();
        try
        {
          var rootedPath = m_FS.CombinePaths(m_FSRootPath, path);
          return getConfigFromExistingFile(session, rootedPath);
        }
        finally
        {
          Monitor.Exit(session);
        }
      }

19 Source : Metabank.cs
with MIT License
from azist

private FileSystemSession obtainSession()
            {
              EnsureObjectNotDisposed();
              var callerThread = Thread.CurrentThread;
              _fss session;

              lock(m_FSSessionCache)
              {
                if (m_FSSessionCacheThread==null)
                {
                  m_FSSessionCacheThread = new Thread(
                    (object objBank)=>
                    {
                      var bank  = objBank as Metabank;
                      while(bank.Active)
                      {
                        m_FSSessionCacheThreadWaiter.WaitOne(1000);
                        try
                        {
                              lock(m_FSSessionCache)
                              {
                                var now = DateTime.UtcNow;
                                var allKvp = m_FSSessionCache.ToList();
                                foreach(var kvp in allKvp)
                                  if (Monitor.TryEnter(kvp.Value.Session))
                                    try
                                    {
                                      if ((now - kvp.Value.LastAccess).TotalSeconds > 30)//how long to keep fsSession open
                                      {
                                        try{ kvp.Value.Session.Dispose();}
                                        finally{m_FSSessionCache.Remove(kvp.Key);}
                                      }
                                    }
                                    finally
                                    {
                                      Monitor.Exit(kvp.Value.Session);
                                    }
                              }
                        }
                        catch(Exception error)
                        {
                          WriteLog(MessageType.Error,
                              "obtainSession(timedLoop)",
                              "Thread '{0}' leaked: {1}".Args(m_FSSessionCacheThread.Name, error.ToMessageWithType()),
                              error);
                        }

                      }//while
                    }
                  );
                  m_FSSessionCacheThread.IsBackground = false;
                  m_FSSessionCacheThread.Name = "Metabank FS Session Cache Thread";
                  m_FSSessionCacheThreadWaiter = new AutoResetEvent(false);
                  m_FSSessionCacheThread.Start(this);
                }//if thread==null

                if (m_FSSessionCache.TryGetValue(callerThread, out session))
                {
                  session.LastAccess = DateTime.UtcNow;
                }
                else
                {
                  session = new _fss{ Session = m_FS.StartSession(m_FSSessionConnectParams), LastAccess = DateTime.UtcNow};
                  m_FSSessionCache.Add(callerThread, session);
                }

                Monitor.Enter(session.Session);
                return session.Session;
              }


            }

19 Source : Metabank.cs
with MIT License
from azist

internal T fsAccess<T>(string operationName, string path, Func<FileSystemSession, FileSystemDirectory, T> body)
      {
        var session = obtainSession();
        try
        {
          var catPath = m_FS.CombinePaths(m_FSRootPath, path);
          var catDir = session[catPath] as FileSystemDirectory;

          if (catDir==null) throw new MetabaseException(StringConsts.METABASE_PATH_NOT_FOUND_ERROR.Args(operationName, catPath));

          T result;
          try
          {
            result = body(session, catDir);
          }
          finally
          {
            //close all file and directory handles
            var sessionItems = session.Items.ToList();
            foreach(var item in sessionItems)
              item.Dispose();
          }
          return result;
        }
        finally
        {
          Monitor.Exit(session);
        }
      }

19 Source : LockServerService.cs
with MIT License
from azist

private void removeExpiredSessions(DateTime now)
    {
      int totalTimedOut = 0;
      foreach( var session in m_Sessions)//thread-safe snapshot
      {
        if (!Running) return;

        if (Monitor.TryEnter(session))
          try
          {
            var sessionMaxAge = session.Data.MaxAgeSec.HasValue ? session.Data.MaxAgeSec.Value : this.m_DefaultSessionMaxAgeSec;
            if ((now - session.m_LastInteractionUTC).TotalSeconds > sessionMaxAge)//session times out
            {
              m_Sessions.Unregister( session );
              session.Dispose();
              totalTimedOut++;
            }
          }
          finally
          {
            Monitor.Exit(session);
          }
      }

      if (m_InstrumentationEnabled)
        Interlocked.Increment(ref m_stat_ExpiredSessions);

    }

19 Source : PileMutableTests.cs
with MIT License
from azist

[Run("cnt=1        tcount=8  seconds=20")]
      [Run("cnt=12       tcount=8  seconds=20")]
      [Run("cnt=256      tcount=8  seconds=30")]
      [Run("cnt=1024     tcount=8  seconds=30")]
      [Run("cnt=1048576  tcount=12 seconds=60")]
      public void TestThreadSafety(int cnt, int tcount, int seconds)
      {
        using (var pile = new DefaultPile(NOPApplication.Instance))
        {
          var App = pile.App;

          // pile.SegmentSize = 64 * 1024 * 1024;
          pile.Start();

          var data = new PilePointer[cnt];
          for(var i=0; i<cnt; i++)
            data[i] = pile.Put(new byte[0], preallocateBlockSize: Memory.PTR_RAW_BYTE_SIZE + (137 * (i%17)));

          var lst = new List<Task>();

          long statRead = 0;
          long statPut = 0;
          long statDelete = 0;

          var sw = Stopwatch.StartNew();
          var sd = DateTime.UtcNow;
          var deleteLock = new object();
          for(var i=0; i<tcount; i++)
           lst.Add( Task.Factory.StartNew( () =>
           {
             while(true)
             {
               var now = DateTime.UtcNow;
               if ((now - sd).TotalSeconds>seconds) break;

               var it = App.Random.NextScaledRandomInteger(10,100);
               for(var j=0; j<it; j++)
               {
                 var pp = data[App.Random.NextScaledRandomInteger(0, cnt-1)];
                 Aver.IsTrue( pile.Get(pp) is byte[] );
                 Interlocked.Increment(ref statRead);
               }

               it = App.Random.NextScaledRandomInteger(10,100);
               for(var j=0; j<it; j++)
               {
                 var pp = data[App.Random.NextScaledRandomInteger(0, cnt-1)];
                 Aver.IsTrue( pile.Put(pp, new byte[App.Random.NextScaledRandomInteger(0,3791)], link: true) );
                 Interlocked.Increment(ref statPut);
               }

               if (App.Random.NextScaledRandomInteger(0,100)>50 && Monitor.TryEnter(deleteLock))
               try
               {
                 var newData = (PilePointer[])data.Clone();
                 it = App.Random.NextScaledRandomInteger(0, 10 + (cnt / 2));
                 var toDelete = new List<PilePointer>();
                 for(var j=0; j<it; j++)
                 {
                   var idx = App.Random.NextScaledRandomInteger(0, cnt-1);
                   toDelete.Add( newData[idx] );
                   newData[idx] = pile.Put(new byte[12], preallocateBlockSize: App.Random.NextScaledRandomInteger(24, 1024));
                 }
                 data = newData;//atomic;
                 Thread.Sleep(1000);
                 foreach(var pp in toDelete)
                 {
                   Aver.IsTrue( pile.Delete(pp) );
                   Interlocked.Increment(ref statDelete);
                 }
               }
               finally
               {
                 Monitor.Exit(deleteLock);
               }

             }
           }, TaskCreationOptions.LongRunning));

          Task.WaitAll(lst.ToArray());

          var el = sw.ElapsedMilliseconds;

          Console.WriteLine("Read {0:n0} at {1:n0} ops/sec".Args(statRead, statRead /(el / 1000d)));
          Console.WriteLine("Put {0:n0} at {1:n0} ops/sec".Args(statPut, statPut /(el / 1000d)));
          Console.WriteLine("Deleted {0:n0} at {1:n0} ops/sec".Args(statDelete, statDelete /(el / 1000d)));

          for(var i=0; i<data.Length; i++)
           Aver.IsTrue( pile.Delete(data[i]) );


          Aver.AreEqual(0, pile.ObjectCount);
          Aver.AreEqual(0, pile.ObjectLinkCount);
          Aver.AreEqual(0, pile.AllocatedMemoryBytes);

        }
      }

19 Source : WriterReaderPhaser.cs
with MIT License
from Azure

public void ReaderUnlock()
        {
            Monitor.Exit(_readerLock);
        }

19 Source : HttpClientFactory.cs
with MIT License
from Azure

private void OnCleanup(object state) {
            StopCleanupTimer();
            if (Monitor.TryEnter(_cleanupActiveLock)) {
                try {
                    var initialCount = _expiredHandlers.Count;
                    for (var i = 0; i < initialCount; i++) {
#pragma warning disable IDE0068 // Use recommended dispose pattern
                        _expiredHandlers.TryDequeue(out var entry);
#pragma warning restore IDE0068 // Use recommended dispose pattern
                        if (entry.CanDispose) {
                            try {
                                entry.Dispose();
                            }
                            catch (Exception ex) {
                                _logger.Error(ex, "Failed to cleanup handler {name}",
                                    entry.Name);
                            }
                        }
                        else {
                            // If the entry is still live, put it back in the
                            // queue so we can process it during the next cycle.
                            _expiredHandlers.Enqueue(entry);
                        }
                    }
                }
                finally {
                    Monitor.Exit(_cleanupActiveLock);
                }
            }
            if (_expiredHandlers.Count > 0) {
                StartCleanupTimer();
            }
        }

19 Source : LimitingScheduler.cs
with MIT License
from Azure

protected sealed override IEnumerable<Task> GetScheduledTasks() {
                var lockTaken = false;
                try {
                    Monitor.TryEnter(_tasks, ref lockTaken);
                    if (lockTaken) {
                        return _tasks.ToArray();
                    }
                    throw new NotSupportedException();
                }
                finally {
                    if (lockTaken) {
                        Monitor.Exit(_tasks);
                    }
                }
            }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1 )
      {
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            object result = TrampolineHandler.Func( t1, TrampolineInitializer.Data );

            return result;
         }
         finally
         {
            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            object result = TrampolineHandler.Func( t1, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2, T3 t3 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            data.Parameters[ 1 ] = t3;
            object result = TrampolineHandler.Func( t1, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2, T3 t3, T4 t4 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            data.Parameters[ 1 ] = t3;
            data.Parameters[ 2 ] = t4;
            object result = TrampolineHandler.Func( t1, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            data.Parameters[ 1 ] = t3;
            data.Parameters[ 2 ] = t4;
            data.Parameters[ 3 ] = t5;
            object result = TrampolineHandler.Func( t1, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;
            data.Parameters[ 3 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1 )
      {
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            TrampolineHandler.Action( t1, TrampolineInitializer.Data );
         }
         finally
         {
            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            TrampolineHandler.Action( t1, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2, T3 t3 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            data.Parameters[ 1 ] = t3;
            TrampolineHandler.Action( t1, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2, T3 t3, T4 t4 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            data.Parameters[ 1 ] = t3;
            data.Parameters[ 2 ] = t4;
            TrampolineHandler.Action( t1, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t2;
            data.Parameters[ 1 ] = t3;
            data.Parameters[ 2 ] = t4;
            data.Parameters[ 3 ] = t5;
            TrampolineHandler.Action( t1, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;
            data.Parameters[ 3 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override()
      {
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            object result = TrampolineHandler.Func( null, TrampolineInitializer.Data );

            return result;
         }
         finally
         {
            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            object result = TrampolineHandler.Func( null, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            object result = TrampolineHandler.Func( null, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2, T3 t3 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            data.Parameters[ 2 ] = t3;
            object result = TrampolineHandler.Func( null, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2, T3 t3, T4 t4 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            data.Parameters[ 2 ] = t3;
            data.Parameters[ 3 ] = t4;
            object result = TrampolineHandler.Func( null, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;
            data.Parameters[ 3 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static object Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            data.Parameters[ 2 ] = t3;
            data.Parameters[ 3 ] = t4;
            data.Parameters[ 4 ] = t5;
            object result = TrampolineHandler.Func( null, data );

            return result;
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;
            data.Parameters[ 3 ] = null;
            data.Parameters[ 4 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override()
      {
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            TrampolineHandler.Action( null, TrampolineInitializer.Data );
         }
         finally
         {
            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            TrampolineHandler.Action( null, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            TrampolineHandler.Action( null, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2, T3 t3 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            data.Parameters[ 2 ] = t3;
            TrampolineHandler.Action( null, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2, T3 t3, T4 t4 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            data.Parameters[ 2 ] = t3;
            data.Parameters[ 3 ] = t4;
            TrampolineHandler.Action( null, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;
            data.Parameters[ 3 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Trampolines.cs
with MIT License
from bbepis

static void Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
      {
         var data = TrampolineInitializer.Data;
         try
         {
            Monitor.Enter( TrampolineInitializer.Sync );

            data.Parameters[ 0 ] = t1;
            data.Parameters[ 1 ] = t2;
            data.Parameters[ 2 ] = t3;
            data.Parameters[ 3 ] = t4;
            data.Parameters[ 4 ] = t5;
            TrampolineHandler.Action( null, data );
         }
         finally
         {
            data.Parameters[ 0 ] = null;
            data.Parameters[ 1 ] = null;
            data.Parameters[ 2 ] = null;
            data.Parameters[ 3 ] = null;
            data.Parameters[ 4 ] = null;

            Monitor.Exit( TrampolineInitializer.Sync );
         }
      }

19 Source : Clients.cs
with Apache License 2.0
from beetlex-io

public async Task<ConnectStatus> Connect()
        {
            ConnectStatus result = new ConnectStatus();
            result.NewConnection = false;

            System.Threading.Monitor.Enter(this);
            try
            {
                if (!IsConnected)
                {
                    await OnConnect();
                    result.NewConnection = true;
                }
            }
            finally
            {
                System.Threading.Monitor.Exit(this);
            }

            result.Connected = mConnected;
            return result;
        }

19 Source : ActorCollection.cs
with Apache License 2.0
from beetlex-io

public async Task Initialize()
            {
                if (!mInitialized)
                {
                    System.Threading.Monitor.Enter(Actor);
                    try
                    {
                        if (!mInitialized)
                        {
                            if (Actor is IActorState actorState)
                                await actorState.ActorInit(ActorID);
                        }
                    }
                    finally
                    {
                        mInitialized = true;
                        System.Threading.Monitor.Exit(Actor);
                    }
                }
            }

19 Source : LocalLock.cs
with MIT License
from bing-framework

public bool LockRelease(string key, string value)
        {
            Check.NotNull(key, nameof(key));
            Check.NotNull(value, nameof(value));

            _lockCache.TryGetValue(key, out var obj);
            if (obj != null)
            {
                if (_lockUserCache[key] == value)
                {
                    Monitor.Exit(obj);
                    return true;
                }
                return false;
            }
            return true;
        }

19 Source : LimitedConcurrencyLevelTaskScheduler.cs
with GNU General Public License v3.0
from bonarr

protected sealed override IEnumerable<Task> GetScheduledTasks()
        {
            bool lockTaken = false;
            try
            {
                Monitor.TryEnter(_tasks, ref lockTaken);
                if (lockTaken) return _tasks.ToArray();
                else throw new NotSupportedException();
            }
            finally
            {
                if (lockTaken) Monitor.Exit(_tasks);
            }
        }

19 Source : AssemblyUtilities.cs
with MIT License
from BrunoS3D

private static void Registerreplacedembly_THREADSAFE(replacedembly replacedembly, bool mightNotBeInitialized)
        {
            if (mightNotBeInitialized)
            {
                EnsureInitialized();
            }

            // This immediately fails to acquire the lock if it is not available,
            // deadlocks should be fundamentally impossible.
            if (Monitor.TryEnter(MAIN_LOCK))
            {
                try
                {
                    Registerreplacedembly_NOT_THREADSAFE(replacedembly);
                    replacedembly[] queuedreplacedemblies;

                    while (GetAndClearQueuedreplacedemblies(out queuedreplacedemblies))
                    {
                        for (int i = 0; i < queuedreplacedemblies.Length; i++)
                        {
                            Registerreplacedembly_NOT_THREADSAFE(queuedreplacedemblies[i]);
                        }
                    }
                }
                catch (ReflectionTypeLoadException)
                {
                    // This happens in builds if people are compiling with a subset of .NET
                    // It means we simply skip this replacedembly and its types completely when scanning for formatter types
                }
                finally
                {
                    Monitor.Exit(MAIN_LOCK);
                }
            }
            // We failed to acquire the lock - instead queue the replacedembly
            // There is a possibility that queued replacedemblies are "missed" here,
            // and left in the queue for quite a long time. This is acceptable,
            // however, as EnsureInitialized() processes the queue if necessary,
            // and EnsureInitialized() is called by all API's that rely on
            // replacedemblies being registered.
            else
            {
                lock (replacedEMBLY_LOAD_QUEUE_LOCK)
                {
                    replacedemblyLoadQueue.Enqueue(replacedembly);
                }
            }
        }

19 Source : TradierBrokerage.cs
with Apache License 2.0
from Capnode

private void CheckForFills()
        {
            // reentrance guard
            if (!Monitor.TryEnter(_fillLock))
            {
                return;
            }

            try
            {
                var intradayAndPendingOrders = GetIntradayAndPendingOrders();
                if (intradayAndPendingOrders == null)
                {
                    Log.Error("TradierBrokerage.CheckForFills(): Returned null response!");
                    return;
                }

                var updatedOrders = intradayAndPendingOrders.ToDictionary(x => x.Id);

                // loop over our cache of orders looking for changes in status for fill quanreplacedies
                foreach (var cachedOrder in _cachedOpenOrdersByTradierOrderID)
                {
                    TradierOrder updatedOrder;
                    var hasUpdatedOrder = updatedOrders.TryGetValue(cachedOrder.Key, out updatedOrder);
                    if (hasUpdatedOrder)
                    {
                        // determine if the order has been updated and produce fills accordingly
                        ProcessPotentiallyUpdatedOrder(cachedOrder.Value, updatedOrder);

                        // if the order is still open, update the cached value
                        if (!OrderIsClosed(updatedOrder)) UpdateCachedOpenOrder(cachedOrder.Key, updatedOrder);
                        continue;
                    }

                    // if we made it here this may be a canceled order via another portal, so we need to figure this one
                    // out with its own rest call, do this async to not block this thread
                    if (!_reentranceGuardByTradierOrderID.Add(cachedOrder.Key))
                    {
                        // we don't want to reenter this task, so we'll use a hashset to keep track of what orders are currently in there
                        continue;
                    }

                    var cachedOrderLocal = cachedOrder;
                    Task.Run(() =>
                    {
                        try
                        {
                            var updatedOrderLocal = GetOrder(cachedOrderLocal.Key);
                            if (updatedOrderLocal == null)
                            {
                                Log.Error($"TradierBrokerage.CheckForFills(): Unable to locate order {cachedOrderLocal.Key} in cached open orders.");
                                throw new InvalidOperationException("TradierBrokerage.CheckForFills(): GetOrder() return null response");
                            }

                            UpdateCachedOpenOrder(cachedOrderLocal.Key, updatedOrderLocal);
                            ProcessPotentiallyUpdatedOrder(cachedOrderLocal.Value, updatedOrderLocal);
                        }
                        catch (Exception err)
                        {
                            Log.Error(err);
                            OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, "PendingOrderNotReturned",
                                "An error occurred while trying to resolve fill events from Tradier orders: " + err));
                        }
                        finally
                        {
                            // signal that we've left the task
                            _reentranceGuardByTradierOrderID.Remove(cachedOrderLocal.Key);
                        }
                    });
                }

                // if we get order updates for orders we're unaware of we need to bail, this can corrupt the algorithm state
                var unknownOrderIDs = updatedOrders.Where(IsUnknownOrderID).ToHashSet(x => x.Key);
                unknownOrderIDs.ExceptWith(_verifiedUnknownTradierOrderIDs);
                var fireTask = unknownOrderIDs.Count != 0 && _unknownTradierOrderIDs.Count == 0;
                foreach (var unknownOrderID in unknownOrderIDs)
                {
                    _unknownTradierOrderIDs.Add(unknownOrderID);
                }

                if (fireTask)
                {
                    // wait a second and then check the order provider to see if we have these broker IDs, maybe they came in later (ex, symbol denied for short trading)
                    Task.Delay(TimeSpan.FromSeconds(2)).ContinueWith(t =>
                    {
                        var localUnknownTradierOrderIDs = _unknownTradierOrderIDs.ToHashSet();
                        _unknownTradierOrderIDs.Clear();
                        try
                        {
                            // verify we don't have them in the order provider
                            Log.Trace("TradierBrokerage.CheckForFills(): Verifying missing brokerage IDs: " + string.Join(",", localUnknownTradierOrderIDs));
                            var orders = localUnknownTradierOrderIDs.Select(x => _orderProvider.GetOrderByBrokerageId(x)).Where(x => x != null);
                            var stillUnknownOrderIDs = localUnknownTradierOrderIDs.Where(x => !orders.Any(y => y.BrokerId.Contains(x.ToStringInvariant()))).ToList();
                            if (stillUnknownOrderIDs.Count > 0)
                            {
                                // fetch all rejected intraday orders within the last minute, we're going to exclude rejected orders from the error condition
                                var recentOrders = GetIntradayAndPendingOrders().Where(x => x.Status == TradierOrderStatus.Rejected)
                                    .Where(x => DateTime.UtcNow - x.TransactionDate < TimeSpan.FromMinutes(1)).ToHashSet(x => x.Id);

                                // remove recently rejected orders, sometimes we'll get updates for these but we've already marked them as rejected
                                stillUnknownOrderIDs.RemoveAll(x => recentOrders.Contains(x));

                                if (stillUnknownOrderIDs.Count > 0)
                                {
                                    // if we still have unknown IDs then we've gotta bail on the algorithm
                                    var ids = string.Join(", ", stillUnknownOrderIDs);
                                    Log.Error("TradierBrokerage.CheckForFills(): Unable to verify all missing brokerage IDs: " + ids);
                                    OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Error, "UnknownOrderId", "Received unknown Tradier order id(s): " + ids));
                                    return;
                                }
                            }
                            foreach (var unknownTradierOrderID in localUnknownTradierOrderIDs)
                            {
                                // add these to the verified list so we don't check them again
                                _verifiedUnknownTradierOrderIDs.Add(unknownTradierOrderID);
                            }
                            Log.Trace("TradierBrokerage.CheckForFills(): Verified all missing brokerage IDs.");
                        }
                        catch (Exception err)
                        {
                            // we need to recheck these order ids since we failed, so add them back to the set
                            foreach (var id in localUnknownTradierOrderIDs) _unknownTradierOrderIDs.Add(id);

                            Log.Error(err);
                            OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, "UnknownIdResolution", "An error occurred while trying to resolve unknown Tradier order IDs: " + err));
                        }
                    });
                }
            }
            catch (Exception err)
            {
                Log.Error(err);
                OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, "CheckForFillsError", "An error occurred while checking for fills: " + err));
            }
            finally
            {
                Monitor.Exit(_fillLock);
            }
        }

19 Source : Brokerage.cs
with Apache License 2.0
from Capnode

public virtual bool PerformCashSync(IAlgorithm algorithm, DateTime currentTimeUtc, Func<TimeSpan> getTimeSinceLastFill)
        {
            try
            {
                // prevent reentrance in this method
                if (!Monitor.TryEnter(_performCashSyncReentranceGuard))
                {
                    Log.Trace("Brokerage.PerformCashSync(): Reentrant call, cash sync not performed");
                    return false;
                }

                Log.Trace("Brokerage.PerformCashSync(): Sync cash balance");

                var balances = new List<CashAmount>();
                try
                {
                    balances = GetCashBalance();
                }
                catch (Exception err)
                {
                    Log.Error(err, "Error in GetCashBalance:");
                }

                if (balances.Count == 0)
                {
                    Log.Trace("Brokerage.PerformCashSync(): No cash balances available, cash sync not performed");
                    return false;
                }

                // Adds currency to the cashbook that the user might have deposited
                foreach (var balance in balances)
                {
                    if (!algorithm.Portfolio.CashBook.ContainsKey(balance.Currency))
                    {
                        Log.Trace($"Brokerage.PerformCashSync(): Unexpected cash found {balance.Currency} {balance.Amount}", true);
                        algorithm.Portfolio.SetCash(balance.Currency, balance.Amount, 0);
                    }
                }

                // if we were returned our balances, update everything and flip our flag as having performed sync today
                foreach (var kvp in algorithm.Portfolio.CashBook)
                {
                    var cash = kvp.Value;

                    //update the cash if the entry if found in the balances
                    var balanceCash = balances.Find(balance => balance.Currency == cash.Symbol);
                    if (balanceCash != default(CashAmount))
                    {
                        // compare in account currency
                        var delta = cash.Amount - balanceCash.Amount;
                        if (Math.Abs(algorithm.Portfolio.CashBook.ConvertToAccountCurrency(delta, cash.Symbol)) > 5)
                        {
                            // log the delta between
                            Log.Trace($"Brokerage.PerformCashSync(): {balanceCash.Currency} Delta: {delta:0.00}", true);
                        }
                        algorithm.Portfolio.CashBook[cash.Symbol].SetAmount(balanceCash.Amount);
                    }
                    else
                    {
                        //Set the cash amount to zero if cash entry not found in the balances
                        Log.Trace($"Brokerage.PerformCashSync(): {cash.Symbol} was not found in brokerage cash balance, setting the amount to 0", true);
                        algorithm.Portfolio.CashBook[cash.Symbol].SetAmount(0);
                    }
                }
                _syncedLiveBrokerageCashToday = true;
                _lastSyncTimeTicks = currentTimeUtc.Ticks;
            }
            finally
            {
                Monitor.Exit(_performCashSyncReentranceGuard);
            }

            // fire off this task to check if we've had recent fills, if we have then we'll invalidate the cash sync
            // and do it again until we're confident in it
            Task.Delay(TimeSpan.FromSeconds(10)).ContinueWith(_ =>
                {
                    // we want to make sure this is a good value, so check for any recent fills
                    if (getTimeSinceLastFill() <= TimeSpan.FromSeconds(20))
                    {
                        // this will cause us to come back in and reset cash again until we
                        // haven't processed a fill for +- 10 seconds of the set cash time
                        _syncedLiveBrokerageCashToday = false;
                        //_failedCashSyncAttempts = 0;
                        Log.Trace("Brokerage.PerformCashSync(): Unverified cash sync - resync required.");
                    }
                    else
                    {
                        Log.Trace("Brokerage.PerformCashSync(): Verified cash sync.");

                        algorithm.Portfolio.LogMarginInformation();
                    }
                });

            return true;
        }

19 Source : BrokerageConcurrentMessageHandler.cs
with Apache License 2.0
from Capnode

public void HandleNewMessage(T message)
        {
            lock (_messageBuffer)
            {
                if (Monitor.TryEnter(_streamLocked))
                {
                    try
                    {
                        ProcessMessages(message);
                    }
                    finally
                    {
                        Monitor.Exit(_streamLocked);
                    }
                }
                else
                {
                    if (message != default)
                    {
                        // if someone has the lock just enqueue the new message they will process any remaining messages
                        // if by chance they are about to free the lock, no worries, we will always process first any remaining message first see 'ProcessMessages'
                        _messageBuffer.Enqueue(message);
                    }
                }
            }
        }

19 Source : BrokerageConcurrentMessageHandler.cs
with Apache License 2.0
from Capnode

public void WithLockedStream(Action code)
        {
            Monitor.Enter(_streamLocked);
            try
            {
                code();
            }
            finally
            {
                // once we finish our 'code' we will process any message that come through,
                // to make sure no message get's left behind (race condition between us finishing 'ProcessMessages'
                // and some message being enqueued to it, we just take a lock on the buffer
                lock (_messageBuffer)
                {
                    // we release the '_streamLocked' first so by the time we release '_messageBuffer' any new message is processed immediately and not enqueued
                    Monitor.Exit(_streamLocked);
                    ProcessMessages();
                }
            }
        }

19 Source : DbContentFactory.cs
with Apache License 2.0
from ccnetcore

public static DataContext GetCurrentDbContent()
        {

            DataContext db = CallContext.GetData("DbContext") as DataContext;

            if (db == null)//线程在数据槽里面没有此上下文
            {
                db = Webcontext;
                CallContext.SetData("DbContext", db);//放到数据槽中去,DbContext是key,db是value
            }

            try
            {
                    Monitor.Exit(myLock);
            }
            catch
            {
            }


            return db;


        }

19 Source : ManualHisDataMemoryBlock.cs
with Apache License 2.0
from cdy816

public void Relase()
        {
            Monitor.Exit(this);
        }

19 Source : 001_LockAcquiredOutsideTryClause.cs
with MIT License
from cezarypiatek

public void DoSth1()
        {
            Monitor.Enter(myLockObj);
            try
            {

            }
            finally
            {
                Monitor.Exit(myLockObj);
            }
        }

19 Source : 001_LockAcquiredOutsideTryClause.cs
with MIT License
from cezarypiatek

public void DoSth2()
        {
            var lockAcquired = Monitor.TryEnter(myLockObj);
            try
            {

            }
            finally
            {
                if(lockAcquired)
                    Monitor.Exit(myLockObj);
            }
        }

19 Source : 002_LockAcquiredInsideTryClause.cs
with MIT License
from cezarypiatek

public void DoSth1()
        {
            try
            {
                Monitor.Enter(myLockObj);
            }
            finally
            {
                Monitor.Exit(myLockObj);
            }
        }

19 Source : 002_LockAcquiredInsideTryClause.cs
with MIT License
from cezarypiatek

public void DoSth2()
        {
            var lockAcquired = false;
            try
            {
                lockAcquired = Monitor.TryEnter(myLockObj);
            }
            finally
            {
                if(lockAcquired)
                    Monitor.Exit(myLockObj);
            }
        }

19 Source : 003_LockReleasedOutsideFinallyClause.cs
with MIT License
from cezarypiatek

public void DoSth1()
        {
            Monitor.Enter(myLockObj);
            Monitor.Exit(myLockObj);
        }

19 Source : 001_LockOnNonReadonlyField.cs
with MIT License
from cezarypiatek

public void DoSth2()
        {
            Monitor.Enter(lockobj);
            Monitor.Exit(lockobj);
        }

19 Source : 001_LockOnNonReadonlyField.cs
with MIT License
from cezarypiatek

public void DoSth3()
        {
            var wasTaken = false;
            Monitor.TryEnter(lockobj, ref wasTaken);
            if (wasTaken)
            {
                Monitor.Exit(lockobj);
            }
        }

See More Examples