単純なロックを使用して共有データを管理しています。
どのスレッドがロックを取得したかを知る方法はありますか?
基本的に、誰かがすでにロックを取得していて、解放していません。したがって、後続のすべての操作は、ロックを取得してタイムアウトになるだけです。
デバッガーからは、誰かが既にそれを取得しているため、ロックでスタックしているだけで、「Break All」の後に「Debugger + Windows + Threads」を見ました-ロックに入るスレッドはありませんでした。
クリティカル セクションに入ったスレッドは表示されません。
誰かがロックを取得し、そのスレッドが中止された可能性があります。しかし、スレッドが中止されてもロックが解放されることを期待しています。私の予想は間違っていますか？
これが私のクラスです-基本的にはpowershell cmd runnerであり、cmdは複数のスレッドから実行できます：
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
}