private void OnTimedEvent(Timer timer, IThreadRunnable task)
{
lock (this)
{
this._timers.Remove(timer);
}
task.Run();
}
private void OnTimedEvent(Timer timer, IThreadRunnable task)
{
lock (this)
{
this._timers.Remove(timer);
}
task.Run();
}
/// <summary>
/// Loop, executing targets as they are received.
/// </summary>
public override void Run()
{
bool ran = false;
while (run)
{
try
{
lock (lockObject)
{
while (runnable == null && run)
{
Monitor.Wait(lockObject, 500);
}
if (runnable != null)
{
ran = true;
runnable.Run();
}
}
}
catch (Exception exceptionInRunnable)
{
log.Error("Error while executing the Runnable: ", exceptionInRunnable);
}
finally
{
lock (lockObject)
{
runnable = null;
}
// repair the thread in case the runnable mucked it up...
Priority = tp.ThreadPriority;
if (runOnce)
{
run = false;
tp.ClearFromBusyWorkersList(this);
}
else if (ran)
{
ran = false;
tp.MakeAvailable(this);
}
}
}
log.Debug("WorkerThread is shut down");
}
/// <summary>
/// Loop, executing targets as they are received.
/// </summary>
public override void Run()
{
bool ran = false;
while (_run)
{
try
{
lock (_lockObject)
{
while (_runnable == null && _run)
{
Monitor.Wait(_lockObject, 500);
}
if (_runnable != null)
{
ran = true;
_runnable.Run();
}
}
}
catch (Exception exceptionInRunnable)
{
throw exceptionInRunnable;
}
finally
{
lock (_lockObject)
{
_runnable = null;
}
// repair the thread in case the runnable mucked it up...
Priority = _tp.ThreadPriority;
if (_runOnce)
{
_run = false;
_tp.ClearFromBusyWorkersList(this);
}
else if (ran)
{
ran = false;
_tp.MakeAvailable(this);
}
}
}
}
/// <summary> The method that is run by the thread. This method first joins the
/// idle state in the pool and then enters an infinite loop. In this
/// loop it waits until a target to run exists and runs it. Once the
/// target's run() method is done it re-joins the idle state and
/// notifies the waiting lock object, if one exists.
///
/// <P>An interrupt on this thread has no effect other than forcing a
/// check on the target. Normally the target is checked every time the
/// thread is woken up by notify, no interrupts should be done.
///
/// <P>Any exception thrown by the target's 'run()' method is catched
/// and this thread is not affected, except for 'ThreadDeath'. If a
/// 'ThreadDeath' exception is catched a warning message is printed by
/// the 'FacilityManager' and the exception is propagated up. For
/// exceptions which are subclasses of 'Error' or 'RuntimeException'
/// the corresponding error condition is set and this thread is not
/// affected. For any other exceptions a new 'RuntimeException' is
/// created and the error condition is set, this thread is not affected.
///
/// </summary>
override public void Run()
{
// Join the idle threads list
Enclosing_Instance.putInIdleList(this);
// Permanently lock the object while running so that target can
// not be changed until we are waiting again. While waiting for a
// target the lock is released.
lock (this)
{
while (true)
{
// Wait until we get a target
while (target == null)
{
try
{
System.Threading.Monitor.Wait(this);
}
catch (System.Threading.ThreadInterruptedException e)
{
}
}
// Run the target and catch all possible errors
try
{
target.Run();
}
//UPGRADE_NOTE: Exception 'java.lang.ThreadDeath' was converted to 'System.InvalidOperationException' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'"
catch (System.Threading.ThreadAbortException td)
{
// We have been instructed to abruptly terminate
// the thread, which should never be done. This can
// cause another thread, or the system, to lock.
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Thread.stop() called on a ThreadPool " + "thread or ThreadDeath thrown. This is " + "deprecated. Lock-up might occur.");
throw td;
}
catch (System.InvalidOperationException e)
{
Enclosing_Instance.targetE = e;
}
//UPGRADE_NOTE: Exception 'java.lang.Throwable' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'"
catch (System.Exception e)
{
// A totally unexpected error has occurred
// (Thread.stop(Throwable) has been used, which should
// never be.
Enclosing_Instance.targetRE = new System.Exception("Unchecked exception " + "thrown by target's " + "run() method in pool " + Enclosing_Instance.poolName + ".");
}
// Join idle threads
Enclosing_Instance.putInIdleList(this);
// Release the target and notify lock (i.e. wakeup)
target = null;
if (lock_Renamed != null)
{
lock (lock_Renamed)
{
if (doNotifyAll)
{
System.Threading.Monitor.PulseAll(lock_Renamed);
}
else
{
System.Threading.Monitor.Pulse(lock_Renamed);
}
}
}
}
}
}
/// <summary>
/// Loop, executing targets as they are received.
/// </summary>
public override void Run()
{
bool ran = false;
bool shouldRun;
lock (this)
{
shouldRun = run;
}
while (shouldRun)
{
try
{
lock (this)
{
while (runnable == null && run)
{
Monitor.Wait(this, 500);
}
if (runnable != null)
{
ran = true;
runnable.Run();
}
}
}
catch (Exception)
{
}
finally
{
lock (this)
{
runnable = null;
}
// repair the thread in case the runnable mucked it up...
if (Priority != tp.ThreadPriority)
{
Priority = tp.ThreadPriority;
}
if (runOnce)
{
lock (this)
{
run = false;
}
tp.ClearFromBusyWorkersList(this);
}
else if (ran)
{
ran = false;
tp.MakeAvailable(this);
}
}
// read value of run within synchronized block to be
// sure of its value
lock (this)
{
shouldRun = run;
}
}
}
/// <summary>
/// Loop, executing targets as they are received.
/// </summary>
public override void Run()
{
var ran = false;
bool runOnce;
bool shouldRun;
lock (this)
{
runOnce = (runnable != null);
shouldRun = run;
}
while (shouldRun)
{
try
{
lock (this)
{
while (runnable == null && run)
{
Monitor.Wait(this, 500);
}
}
if (runnable != null)
{
ran = true;
runnable.Run();
}
}
catch (Exception exceptionInRunnable)
{
Log.Error("Error while executing the Runnable: ", exceptionInRunnable);
}
finally
{
lock (this)
{
runnable = null;
}
// repair the thread in case the runnable mucked it up...
if (Priority != tp.ThreadPriority)
{
Priority = tp.ThreadPriority;
}
if (runOnce)
{
lock (this)
{
run = false;
}
}
else if (ran)
{
ran = false;
tp.MakeAvailable(this);
}
}
// read value of run within synchronized block to be
// sure of its value
lock (this)
{
shouldRun = run;
}
}
Log.Debug("WorkerThread is shutting down");
}