/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.felix.threaddump.internal.jdk5;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.felix.threaddump.internal.ThreadDumper;
import org.apache.felix.threaddump.internal.ThreadWriter;
/**
* {@link ThreadDumper} implementation which relies on JMX APIs in JDK1.5.
*/
public class Jdk15ThreadDumper implements ThreadDumper
{
private static final String DEADLOCK = "Found {0} {0,choice,1#deadlock|1<deadlocks}.";
public void printThreads(ThreadWriter threadWriter)
{
final ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
// thread Infos
final ThreadInfo[] infos = getThreadInfo(threadMXBean);
// map thread ids to infos idx
final Map/* <long, int> */id2idx = new HashMap();
for (int i = 0; i < infos.length; i++)
{
id2idx.put(Long.valueOf(infos[i].getThreadId()), Integer.valueOf(i));
}
// create an array of all Thread objects indexed equivalent to Infos
final Thread[] threads = getThreads(id2idx);
// print the thread information
for (int i = 0; i < infos.length; i++)
{
printThreadInfo(threadWriter, threads[i], infos[i]);
threadWriter.printEmptyLine();
}
// dupm deadlock information
long[] deadlockedThreadsIds = findDeadlockedThreads(threadMXBean);
if (deadlockedThreadsIds != null)
{
List/* <List<int>> */deadlocks = new ArrayList();
for (int i = 0; i < deadlockedThreadsIds.length; i++)
{
Long l = Long.valueOf(deadlockedThreadsIds[i]);
Integer idx = (Integer) id2idx.remove(l);
if (idx != null)
{
List/* <int> */idxs = new ArrayList();
deadlocks.add(idxs);
do
{
idxs.add(idx);
ThreadInfo info = infos[idx.intValue()];
if (info != null)
{
idx = (Integer) id2idx.remove(Long.valueOf(info.getLockOwnerId()));
}
else
{
idx = null;
}
}
while (idx != null);
}
}
for (Iterator di = deadlocks.iterator(); di.hasNext();)
{
List idxs = (List) di.next();
threadWriter.printEmptyLine();
threadWriter.println("Found one Java-level deadlock:");
threadWriter.println("=============================");
for (Iterator ii = idxs.iterator(); ii.hasNext();)
{
Integer idx = (Integer) ii.next();
ThreadInfo info = infos[idx.intValue()];
printDeadlockedThreadInfo(threadWriter, info);
}
threadWriter.printEmptyLine();
threadWriter.println("Java stack information for the threads listed above:");
threadWriter.println("===================================================");
for (Iterator ii = idxs.iterator(); ii.hasNext();)
{
int idx = ((Integer) ii.next()).intValue();
printThreadInfo(threadWriter, threads[idx], infos[idx]);
}
}
threadWriter.printEmptyLine();
threadWriter.println(DEADLOCK, new Object[]
{ Integer.valueOf(deadlocks.size()) });
threadWriter.printEmptyLine();
}
}
private void printThreadInfo(ThreadWriter threadWriter, Thread t, ThreadInfo info)
{
if (t == null)
{
return;
}
short status = ThreadStateConverter.toStatus(t.getState());
threadWriter.printThread(t.getName(), t.isDaemon(), t.getPriority(), t.getId(), status);
printStackTrace(threadWriter, info);
}
protected ThreadInfo[] getThreadInfo(ThreadMXBean threadMXBean)
{
long[] threadIds = threadMXBean.getAllThreadIds();
return threadMXBean.getThreadInfo(threadIds, Integer.MAX_VALUE);
}
protected long[] findDeadlockedThreads(ThreadMXBean threadMXBean)
{
return threadMXBean.findMonitorDeadlockedThreads();
}
protected void printStackTrace(ThreadWriter threadWriter, ThreadInfo info)
{
threadWriter.printStackTrace(info.getStackTrace());
}
protected void printDeadlockedThreadInfo(ThreadWriter threadWriter, ThreadInfo info)
{
threadWriter.println("\"{0}\":", new Object[]
{ info.getThreadName() });
threadWriter.println(" waiting to lock monitor,");
threadWriter.println(" which is held by \"{0}\"", new Object[]
{ info.getLockOwnerName() });
}
private static Thread[] getThreads(final Map/* <long, int> */id2idx)
{
// find root thread group
ThreadGroup g = Thread.currentThread().getThreadGroup();
while (g.getParent() != null)
{
g = g.getParent();
}
int numThreads = g.activeCount();
Thread[] threads = new Thread[numThreads * 2];
int actualThreads = g.enumerate(threads);
if (threads.length == actualThreads)
{
// some threads have been missed !!
}
Thread[] result = new Thread[id2idx.size()];
for (int i = 0; i < threads.length; i++)
{
Thread t = threads[i];
if (t != null)
{
Integer idx = (Integer) id2idx.get(Long.valueOf(t.getId()));
if (idx != null)
{
result[idx.intValue()] = t;
}
}
}
return result;
}
}