if (Monitor.TryEnter(lockObject, 300)) {
    try {
        // Place code protected by the Monitor here.
    }
    finally {
        Monitor.Exit(this);
    }
}
else {
    // Code to execute if the attempt times out.
}

var lockObj = new Object();
int timeout = 500;
bool lockTaken = false;
 
try {
   Monitor.TryEnter(lockObj, timeout, ref lockTaken);
   if (lockTaken) {
      // The critical section.
   }
   else {
      // The lock was not acquired.
   }
}
finally {
   // Ensure that the lock is released.
   if (lockTaken) {
      Monitor.Exit(lockObj);
   }   
}

public class MyClass
{
	private static object m_lockObjStartJob = new object(); // <----
 
	private static Logger m_logger = LogManager.GetCurrentClassLogger();
 
        public bool IsStarted
        {
            [MethodImpl(MethodImplOptions.Synchronized)]
            get;
 
            [MethodImpl(MethodImplOptions.Synchronized)]
            set;
        } //volatile
        /// <summary>
        /// Indica se il Thread è abilitato. Posto a false dalle richieste di Stop del processo
        /// </summary>
        public bool Enabled 
        {
            //[MethodImpl(MethodImplOptions.Synchronized)]
            get;
            //[MethodImpl(MethodImplOptions.Synchronized)]
            set; 
        } //volatile
 
 
	public void StartJob()
	{
		string strMsg4Log = string.Empty;
 
		try// <----
		{
			if (Monitor.TryEnter(m_lockObjStartJob, 500))// <----
			{
				try
				{
					#region Core
					// ...
					#endregion
				}
				catch (Exception ex)
				{
					// ...
                                        IsStarted = Enabled = false;
				}
				finally
				{
					Monitor.Exit(m_lockObjStartJob);// <----
				}
			}
			else
			{
				strMsg4Log = string.Format("StartJob() is still in use, thread killed!");// <----
				m_logger.Warn(strMsg4Log);
			}
		}
		catch (Exception ex)
		{
			// ...
                        IsStarted = Enabled = false;
		}
	}
}

#region Aggiornamento MODELLO
if (lstAIVDM4Model.Count > 0)
{
	if (Monitor.TryEnter(ShipData.Instance.lstAIVDM, new TimeSpan(0, 0, 2)))
	{
		try
		{
			ShipData.Instance.lstAIVDM.Clear();
			ShipData.Instance.lstAIVDM.AddRange(lstAIVDM4Model);
			//ShipData.Instance.lstAIVDM = lstAIVDM4Model; <--- ERRORE: Object synchronization method was called from an unsynchronized block of code.
			m_loggerMain.Debug("OK, {0} AIS", lstAIVDM4Model.Count);
		}
		catch (Exception ex)
		{
			m_loggerMain.Error("KO {0}", ex.Message);
		}
		finally
		{
			Monitor.Exit(ShipData.Instance.lstAIVDM);
		}
	}
}
#endregion

try
{
	lock (this.CacheLock[cacheKey])
	{
		string val;
		this.CacheValue.TryGetValue(cacheKey, out val);
		if (string.IsNullOrEmpty(val))
		{
			if (_wfHelper != null)
			{
				this.CacheValue[cacheKey] = this._wfHelper.Get(cacheKey);
			}
			else
				this.CacheValue[cacheKey] = string.Empty;
		}
		shipValuesManager = JSONHelper.Deserialize<ValuesManager>(this.CacheValue[cacheKey]);
	}
}
catch (Exception ex)
{
	Logger.ErrorException(string.Format("Exception retrieve cache information from key {0}. Create new cache", cacheKey), ex);
	shipValuesManager = new ValuesManager();
	resultCode += "ERR_CACHE,";
}

internal class MyClass
{
    private readonly object _syncRoot = new Object();
 
    public void DoSomething() 
    {
        lock(_syncRoot)
        {
            ...
        }
    }
 
    public void DoSomethingElse() 
    {
        lock(_syncRoot)
        {
            ...
        }
    }
}

internal class MyClass
{

   [MethodImpl(MethodImplOptions.Synchronized)]
   public void DoSomething() 
   {
       ...
   }
   [MethodImpl(MethodImplOptions.Synchronized)]
   public void DoSomethingElse() 
   {
       ...
   }

}