我只是使用简单的锁来管理一些共享数据。
有没有办法知道哪个线程获得了锁？
基本上有人已经获得了锁并且没有释放它。因此，所有后续操作都只是简单地锁定和超时。
我有点卡住，因为从调试器开始它只是卡在锁定状态，因为有人已经获得了它，我在“Break All”之后查看了“Debugger + Windows + Threads” - 没有线程进入锁定状态。
它没有显示任何进入临界区的线程。
有可能有人获得了锁并且该线程已被中止。但我希望即使线程已中止，锁也会被释放。我的期望错了吗？
这是我的课程 - 基本上它是一个 powershell cmd 运行程序，并且 cmds 可以从多个线程执行：
internal abstract class PowerShellCommandRunner : IDisposable
{
#region Fields
protected object m_syncObject = new object();
private PSSession m_psSession = null;
private Runspace m_runspace = null;
#endregion
#region Constructor
public PowerShellCommandRunner(ExchangeApplicationSystem system)
{
if (null == system)
{
throw new ArgumentNullException("ExchangeApplicationSystem");
}
this.ExchangeApplicationSystem = system;
this.PSCredential = this.ExchangeApplicationSystem.Credential.GetPSCredential();
}
#endregion
#region Properties
internal ExchangeApplicationSystem ExchangeApplicationSystem
{
get;
private set;
}
public PSCredential PSCredential
{
get;
protected set;
}
private bool IsNotInitializedOrInvalidRunspace(Runspace runspace)
{
bool flag = (null == runspace) //not initialized
|| (null == runspace.RunspaceStateInfo) //not state info (defensive)
|| (runspace.RunspaceStateInfo.State == RunspaceState.Broken) //runspace state is broken
|| (null != runspace.RunspaceStateInfo.Reason); //there is an exception
return flag;
}
private bool NeedToCreatePsSession
{
get
{
bool flag = (null == this.m_psSession)
|| this.IsNotInitializedOrInvalidRunspace(this.m_psSession.Runspace);
return flag;
}
}
internal Runspace Runspace
{
get
{
lock (this.m_syncObject)
{
if (this.IsNotInitializedOrInvalidRunspace(this.m_runspace))
{
if (null != this.m_runspace)
{
//already have one runspace - close it, before we create another one
this.CloseRunspace();
}
this.m_runspace = RunspaceFactory.CreateRunspace();
this.m_runspace.Open();
}
return this.m_runspace;
}
}
}
#endregion
#region Methods
internal IEnumerable<PSObject> Execute(string cmd, params object[] argumentList)
{
if (string.IsNullOrEmpty(cmd))
{
throw new ArgumentNullException("cmd");
}
return this.Execute(new Command(cmd), argumentList);
}
/// <summary>
/// Sub-classes can do their own specific implementation to create ps-sessions
/// The base class simply performs primitive oepratiosn like managing them.
/// </summary>
/// <returns></returns>
internal abstract PSSession GetPSSession();
/// <summary>
/// Gets the pssession and if reuired updates it as well
/// </summary>
/// <returns></returns>
private PSSession GetAndUpdateManagePSSessionInfRequired()
{
//Note: we dont need to lock as the callers (Exceute methods) will be acquiring the lock before executing the code
//but, just locking it again as the locks are re-entrant
lock (this.m_syncObject)
{
if (this.NeedToCreatePsSession)
{
if (null != this.m_psSession
&& (null != this.m_runspace))
{
//if ps-session exists, remove it from runspace
this.RemovePsSessionFromRunspace();
//Yes, there can be a case where some one already have a reference to the remove session
//that's ok, as the operation simply throws
//And subsequently they will be releasing and re-using the new one.
this.m_psSession = null;
}
//now, open a new session (requesting for a new session from subclasses)
this.m_psSession = this.GetPSSession();
Debug.Assert(null != this.m_psSession);
}
return this.m_psSession;
}
}
internal IEnumerable<PSObject> Execute(Command cmd, params object[] argumentList)
{
if (null == cmd)
{
throw new ArgumentNullException("cmd");
}
lock (this.m_syncObject)
{
//Pipelines cannot be executed concurrently, so serialize it
OperationProgressReporter.Report(string.Format("Executing the following PowerShell Command: {0}", cmd.ToString()));
return this.Runspace.ExecuteCommand(cmd, this.GetAndUpdateManagePSSessionInfRequired(), argumentList);
}
}
internal IEnumerable<PSObject> Execute(ScriptBlock sb, params object[] argumentList)
{
if (null == sb)
{
throw new ArgumentNullException("scriptblock");
}
lock (this.m_syncObject)
{
//Pipelines cannot be executed concurrently, so serialize it
OperationProgressReporter.Report(string.Format("Executing the following PowerShell Command: {0}", sb.ToString()));
return this.Runspace.ExecuteCommand(sb, this.GetAndUpdateManagePSSessionInfRequired(), argumentList);
}
}
private void RemovePsSessionFromRunspace()
{
//not intended to call before acquiring a lock
//(For ex: either while closing runspace or while getting rid of old session and getting a new one (GetAndUpdateManagePSSessionInfRequired)
//but locking it as the locks are re-entrant (defensive)
lock (this.m_syncObject)
{
if ((null != this.m_psSession)
&& (null != this.m_runspace))
{
try
{
string errorMsg = null;
this.m_runspace.RemovePsSessionFromRunspace(this.m_psSession, out errorMsg);
if (!string.IsNullOrEmpty(errorMsg))
{
FxTracing.TraceError(TraceEventId.GeneralError, errorMsg);
}
}
catch (Exception ex)
{
ExceptionManager.GeneralExceptionFilter(ex);
OperationProgressReporter.Report(OperationProgressMessageLevel.Verbose,
string.Format("<DEBUG> Unable to remove PSsession from runspace in '{0}'", this.ExchangeApplicationSystem));
}
}
}
}
private void CloseRunspace()
{
//lcok it
lock (this.m_syncObject)
{
//check again to make sure only one thread enters
if (null != this.m_runspace)
{
try
{
//if a ps-session is created, remove it
if (null != this.m_psSession)
{
//remove the pssession from runspace
this.RemovePsSessionFromRunspace();
}
//then close the runspace
this.m_runspace.Close();
}
catch (Exception ex)
{
//swallow
ExceptionManager.GeneralExceptionFilter(ex);
Debug.Fail(ex.Message);
}
finally
{
//finally, set the runspace to null
//Yes, the runspace can be set to null while another thread can have a reference to old runspace
//its ok as the operation simply fail with invalid runspace state exception (most likely)
//And when they retry they get the updated runspace or get a new one.
//same appraoch as managing ps-session
this.m_runspace = null;
}
}
}
}
#endregion
#region IDisposable
public void Dispose()
{
this.CloseRunspace();
}
#endregion
}
