private static HeapAllocation Load(ThreadMXBean bean)
{
Type <HeapAllocation> @base = typeof(HeapAllocation);
StringBuilder name = (new StringBuilder()).Append(@base.Assembly.GetName().Name).Append('.');
string pkg = bean.GetType().Assembly.GetName().Name;
int start = 0;
int end = pkg.IndexOf('.', start);
while (end > 0)
{
name.Append(toUpperCase(pkg[start])).Append(pkg.Substring(start + 1, end - (start + 1)));
start = end + 1;
end = pkg.IndexOf('.', start);
}
name.Append(toUpperCase(pkg[start])).Append(pkg.Substring(start + 1));
name.Append(@base.Name);
try
{
return(requireNonNull(( HeapAllocation )Type.GetType(name.ToString()).getDeclaredMethod("load", typeof(ThreadMXBean)).invoke(null, bean), "Loader method returned null."));
}
catch (Exception e)
{
//noinspection ConstantConditions -- this can actually happen if the code order is wrong
if (NotAvailable == null)
{
throw new LinkageError("Bad code loading order.", e);
}
return(NotAvailable);
}
}
/// <summary>
/// Creates threads dump and try to mimic JVM stack trace as much as possible to allow existing analytics tools to be used
/// </summary>
/// <returns> string that contains thread dump </returns>
public static string ThreadDump()
{
ThreadMXBean threadMxBean = ManagementFactory.ThreadMXBean;
Properties systemProperties = System.Properties;
return(ThreadDump(threadMxBean, systemProperties));
}
/// <summary>
/// Creates threads dump and try to mimic JVM stack trace as much as possible to allow existing analytics tools to be used
/// </summary>
/// <param name="threadMxBean"> bean to use for thread dump </param>
/// <param name="systemProperties"> dumped vm system properties </param>
/// <returns> string that contains thread dump </returns>
public static string ThreadDump(ThreadMXBean threadMxBean, Properties systemProperties)
{
ThreadInfo[] threadInfos = threadMxBean.dumpAllThreads(true, true);
// Reproduce JVM stack trace as far as possible to allow existing analytics tools to be used
string vmName = systemProperties.getProperty("java.vm.name");
string vmVersion = systemProperties.getProperty("java.vm.version");
string vmInfoString = systemProperties.getProperty("java.vm.info");
StringBuilder sb = new StringBuilder();
sb.Append(string.Format("Full thread dump {0} ({1} {2}):\n\n", vmName, vmVersion, vmInfoString));
foreach (ThreadInfo threadInfo in threadInfos)
{
sb.Append(string.Format("\"{0}\" #{1:D}\n", threadInfo.ThreadName, threadInfo.ThreadId));
sb.Append(" java.lang.Thread.State: ").Append(threadInfo.ThreadState).Append("\n");
StackTraceElement[] stackTrace = threadInfo.StackTrace;
for (int i = 0; i < stackTrace.Length; i++)
{
StackTraceElement e = stackTrace[i];
sb.Append("\tat ").Append(e.ToString()).Append('\n');
// First stack element info can be found in the thread state
if (i == 0 && threadInfo.LockInfo != null)
{
Thread.State ts = threadInfo.ThreadState;
switch (ts)
{
case BLOCKED:
sb.Append("\t- blocked on ").Append(threadInfo.LockInfo).Append('\n');
break;
case WAITING:
sb.Append("\t- waiting on ").Append(threadInfo.LockInfo).Append('\n');
break;
case TIMED_WAITING:
sb.Append("\t- waiting on ").Append(threadInfo.LockInfo).Append('\n');
break;
default:
break;
}
}
foreach (MonitorInfo mi in threadInfo.LockedMonitors)
{
if (mi.LockedStackDepth == i)
{
sb.Append("\t- locked ").Append(mi).Append('\n');
}
}
}
}
return(sb.ToString());
}
public override void run()
{
RuntimeContext.runThread(this);
InSyscall = true;
ThreadMXBean threadMXBean = ManagementFactory.ThreadMXBean;
if (threadMXBean.ThreadCpuTimeEnabled)
{
threadInfo.javaThreadCpuTimeNanos = threadMXBean.CurrentThreadCpuTime;
}
}
/// <summary>Get CPU time in nanoseconds. </summary>
static public long getCpuTime(long id)
{
ThreadMXBean bean = ManagementFactory.getThreadMXBean();
if (!bean.isThreadCpuTimeSupported())
{
return(0L);
}
else
{
return(bean.getThreadCpuTime(id));
}
}
public bool Get()
{
ThreadMXBean threadBean = ManagementFactory.GetThreadMXBean();
ThreadInfo[] threads = threadBean.GetThreadInfo(threadBean.GetAllThreadIds(), 1);
foreach (ThreadInfo thread in threads)
{
if (thread.GetThreadName().StartsWith("TransferFsImageUpload"))
{
return(false);
}
}
return(true);
}
public override void Run(EPServiceProvider epService)
{
string[] engineFields = "engineURI,timestamp,inputCount,inputCountDelta,scheduleDepth".Split(',');
SendTimer(epService, 1000);
string text = "select * from " + typeof(EngineMetric).FullName;
EPStatement stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean());
SendTimer(epService, 10999);
Assert.IsFalse(listener.IsInvoked);
epService.EPAdministrator.CreateEPL("select * from pattern[timer:interval(5 sec)]");
SendTimer(epService, 11000);
EventBean theEvent = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(theEvent, engineFields, new object[] { "default", 11000L, 1L, 1L, 1L });
epService.EPRuntime.SendEvent(new SupportBean());
epService.EPRuntime.SendEvent(new SupportBean());
SendTimer(epService, 20000);
SendTimer(epService, 21000);
theEvent = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(theEvent, engineFields, new object[] { "default", 21000L, 4L, 3L, 0L });
#if false
// Try MBean
ThreadMXBean mbean = ManagementFactory.ThreadMXBean;
if (!mbean.IsThreadCpuTimeEnabled)
{
Assert.Fail("ThreadMXBean CPU time reporting is not enabled");
}
long msecMultiplier = 1000 * 1000;
long msecGoal = 10;
long cpuGoal = msecGoal * msecMultiplier;
long beforeCPU = mbean.CurrentThreadCpuTime;
MyMetricFunctions.TakeCPUTime(cpuGoal);
long afterCPU = mbean.CurrentThreadCpuTime;
Assert.IsTrue((afterCPU - beforeCPU) > cpuGoal);
#endif
}
/// <summary>
/// Assert that there are no threads running whose name matches the
/// given regular expression.
/// </summary>
/// <param name="regex">the regex to match against</param>
public static void AssertNoThreadsMatching(string regex)
{
Pattern pattern = Pattern.Compile(regex);
ThreadMXBean threadBean = ManagementFactory.GetThreadMXBean();
ThreadInfo[] infos = threadBean.GetThreadInfo(threadBean.GetAllThreadIds(), 20);
foreach (ThreadInfo info in infos)
{
if (info == null)
{
continue;
}
if (pattern.Matcher(info.GetThreadName()).Matches())
{
NUnit.Framework.Assert.Fail("Leaked thread: " + info + "\n" + Joiner.On("\n").Join
(info.GetStackTrace()));
}
}
}
public void TestTakeCPUTime()
{
ThreadMXBean mbean = ManagementFactory.ThreadMXBean;
if (!mbean.IsThreadCpuTimeEnabled)
{
Fail("ThreadMXBean CPU time reporting is not enabled");
}
long msecMultiplier = 1000 * 1000;
long msecGoal = 10;
long cpuGoal = msecGoal * msecMultiplier;
long beforeCPU = mbean.CurrentThreadCpuTime;
MyMetricFunctions.TakeCPUTime(cpuGoal);
long afterCPU = mbean.CurrentThreadCpuTime;
Assert.IsTrue((afterCPU - beforeCPU) > cpuGoal);
}
private static int CountTimerThreads()
{
ThreadMXBean threadBean = ManagementFactory.GetThreadMXBean();
int count = 0;
ThreadInfo[] infos = threadBean.GetThreadInfo(threadBean.GetAllThreadIds(), 20);
foreach (ThreadInfo info in infos)
{
if (info == null)
{
continue;
}
foreach (StackTraceElement elem in info.GetStackTrace())
{
if (elem.GetClassName().Contains("Timer"))
{
count++;
break;
}
}
}
return(count);
}
internal static string BuildDeadlockInfo()
{
ThreadMXBean threadBean = ManagementFactory.GetThreadMXBean();
long[] threadIds = threadBean.FindMonitorDeadlockedThreads();
if (threadIds != null && threadIds.Length > 0)
{
StringWriter stringWriter = new StringWriter();
PrintWriter @out = new PrintWriter(stringWriter);
ThreadInfo[] infos = threadBean.GetThreadInfo(threadIds, true, true);
foreach (ThreadInfo ti in infos)
{
PrintThreadInfo(ti, @out);
PrintLockInfo(ti.GetLockedSynchronizers(), @out);
@out.WriteLine();
}
@out.Close();
return(stringWriter.ToString());
}
else
{
return(null);
}
}
private void DoThreadUpdates()
{
ThreadMXBean threadMXBean = ManagementFactory.GetThreadMXBean();
long[] threadIds = threadMXBean.GetAllThreadIds();
ThreadInfo[] threadInfos = threadMXBean.GetThreadInfo(threadIds, 0);
int threadsNew = 0;
int threadsRunnable = 0;
int threadsBlocked = 0;
int threadsWaiting = 0;
int threadsTimedWaiting = 0;
int threadsTerminated = 0;
foreach (ThreadInfo threadInfo in threadInfos)
{
// threadInfo is null if the thread is not alive or doesn't exist
if (threadInfo == null)
{
continue;
}
Thread.State state = threadInfo.GetThreadState();
if (state == Thread.State.New)
{
threadsNew++;
}
else
{
if (state == Thread.State.Runnable)
{
threadsRunnable++;
}
else
{
if (state == Thread.State.Blocked)
{
threadsBlocked++;
}
else
{
if (state == Thread.State.Waiting)
{
threadsWaiting++;
}
else
{
if (state == Thread.State.TimedWaiting)
{
threadsTimedWaiting++;
}
else
{
if (state == Thread.State.Terminated)
{
threadsTerminated++;
}
}
}
}
}
}
}
metrics.SetMetric("threadsNew", threadsNew);
metrics.SetMetric("threadsRunnable", threadsRunnable);
metrics.SetMetric("threadsBlocked", threadsBlocked);
metrics.SetMetric("threadsWaiting", threadsWaiting);
metrics.SetMetric("threadsTimedWaiting", threadsTimedWaiting);
metrics.SetMetric("threadsTerminated", threadsTerminated);
}
