getThreadObserver(string p,
string n,
Ice.Instrumentation.ThreadState s,
Ice.Instrumentation.ThreadObserver o)
{
return(null);
}
public void updateObserver()
{
// Must be called with the thread pool mutex locked
Ice.Instrumentation.CommunicatorObserver obsv = _threadPool._instance.initializationData().observer;
if (obsv != null)
{
_observer = obsv.getThreadObserver(_threadPool._prefix, _name, _state, _observer);
if (_observer != null)
{
_observer.attach();
}
}
}
getThreadObserver(String p, String id, Ice.Instrumentation.ThreadState s,
Ice.Instrumentation.ThreadObserver old)
{
lock (this)
{
Debug.Assert(old == null || old is ThreadObserverI);
if (threadObserver == null)
{
threadObserver = new ThreadObserverI();
threadObserver.reset();
}
return(threadObserver);
}
}
public Ice.Instrumentation.ThreadObserver getThreadObserver(string parent, string id,
Ice.Instrumentation.ThreadState s,
Ice.Instrumentation.ThreadObserver obsv)
{
if (_threads.isEnabled())
{
try
{
Ice.Instrumentation.ThreadObserver del = null;
ThreadObserverI o = obsv is ThreadObserverI ? (ThreadObserverI)obsv : null;
if (_delegate != null)
{
del = _delegate.getThreadObserver(parent, id, s, o != null ? o.getDelegate() : obsv);
}
return(_threads.getObserver(new ThreadHelper(parent, id, s), obsv, del));
}
catch (Exception ex)
{
_metrics.getLogger().error("unexpected exception trying to obtain observer:\n" + ex);
}
}
return(null);
}
public void updateObserver()
{
// Must be called with the thread pool mutex locked
Ice.Instrumentation.CommunicatorObserver obsv = _threadPool._instance.initializationData().observer;
if(obsv != null)
{
_observer = obsv.getThreadObserver(_threadPool._prefix, _name, _state, _observer);
if(_observer != null)
{
_observer.attach();
}
}
}
public void Run()
{
Token token = null;
while (true)
{
lock (this)
{
if (_instance != null)
{
//
// If the task we just ran is a repeated task, schedule it
// again for execution if it wasn't canceled.
//
if (token != null && token.delay > 0)
{
if (_tasks.ContainsKey(token.task))
{
token.scheduledTime = Time.currentMonotonicTimeMillis() + token.delay;
_tokens.Add(token, null);
}
}
}
token = null;
if (_instance == null)
{
break;
}
if (_tokens.Count == 0)
{
_wakeUpTime = long.MaxValue;
Monitor.Wait(this);
}
if (_instance == null)
{
break;
}
while (_tokens.Count > 0 && _instance != null)
{
long now = Time.currentMonotonicTimeMillis();
Token first = null;
foreach (Token t in _tokens.Keys)
{
first = t;
break;
}
Debug.Assert(first != null);
if (first.scheduledTime <= now)
{
_tokens.Remove(first);
token = first;
if (token.delay == 0)
{
_tasks.Remove(token.task);
}
break;
}
_wakeUpTime = first.scheduledTime;
Monitor.Wait(this, (int)(first.scheduledTime - now));
}
if (_instance == null)
{
break;
}
}
if (token != null)
{
try
{
Ice.Instrumentation.ThreadObserver threadObserver = _observer;
if (threadObserver != null)
{
threadObserver.stateChanged(Ice.Instrumentation.ThreadState.ThreadStateIdle,
Ice.Instrumentation.ThreadState.ThreadStateInUseForOther);
try
{
token.task.runTimerTask();
}
finally
{
threadObserver.stateChanged(Ice.Instrumentation.ThreadState.ThreadStateInUseForOther,
Ice.Instrumentation.ThreadState.ThreadStateIdle);
}
}
else
{
token.task.runTimerTask();
}
}
catch (System.Exception ex)
{
lock (this)
{
if (_instance != null)
{
string s = "unexpected exception from task run method in timer thread:\n" + ex;
_instance.initializationData().logger.error(s);
}
}
}
}
}
}
internal void updateObserver(Ice.Instrumentation.CommunicatorObserver obsv)
{
lock(this)
{
Debug.Assert(obsv != null);
_observer = obsv.getThreadObserver("Communicator",
_thread.Name,
Ice.Instrumentation.ThreadState.ThreadStateIdle,
_observer);
if(_observer != null)
{
_observer.attach();
}
}
}
public void updateObserver()
{
lock(this)
{
Ice.Instrumentation.CommunicatorObserver obsv = _instance.initializationData().observer;
if(obsv != null)
{
_observer = obsv.getThreadObserver("Communicator",
_thread.getName(),
Ice.Instrumentation.ThreadState.ThreadStateIdle,
_observer);
if(_observer != null)
{
_observer.attach();
}
}
}
}
