org.elasticsearch.monitor.jvm.DeadlockAnalyzer Maven / Gradle / Ivy
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch 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.elasticsearch.monitor.jvm;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.*;
/**
*
*/
public class DeadlockAnalyzer {
private static final Deadlock NULL_RESULT[] = new Deadlock[0];
private final ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
private static DeadlockAnalyzer INSTANCE = new DeadlockAnalyzer();
public static DeadlockAnalyzer deadlockAnalyzer() {
return INSTANCE;
}
private DeadlockAnalyzer() {
}
public Deadlock[] findDeadlocks() {
long deadlockedThreads[] = threadBean.findMonitorDeadlockedThreads();
if (deadlockedThreads == null || deadlockedThreads.length == 0) {
return NULL_RESULT;
}
ImmutableMap threadInfoMap = createThreadInfoMap(deadlockedThreads);
Set> cycles = calculateCycles(threadInfoMap);
Set> chains = calculateCycleDeadlockChains(threadInfoMap, cycles);
cycles.addAll(chains);
return createDeadlockDescriptions(cycles);
}
private Deadlock[] createDeadlockDescriptions(Set> cycles) {
Deadlock result[] = new Deadlock[cycles.size()];
int count = 0;
for (LinkedHashSet cycle : cycles) {
ThreadInfo asArray[] = cycle.toArray(new ThreadInfo[cycle.size()]);
Deadlock d = new Deadlock(asArray);
result[count++] = d;
}
return result;
}
private Set> calculateCycles(ImmutableMap threadInfoMap) {
Set> cycles = new HashSet<>();
for (Map.Entry entry : threadInfoMap.entrySet()) {
LinkedHashSet cycle = new LinkedHashSet<>();
for (ThreadInfo t = entry.getValue(); !cycle.contains(t); t = threadInfoMap.get(Long.valueOf(t.getLockOwnerId())))
cycle.add(t);
if (!cycles.contains(cycle))
cycles.add(cycle);
}
return cycles;
}
private Set> calculateCycleDeadlockChains(ImmutableMap threadInfoMap, Set> cycles) {
ThreadInfo allThreads[] = threadBean.getThreadInfo(threadBean.getAllThreadIds());
Set> deadlockChain = new HashSet<>();
Set knownDeadlockedThreads = threadInfoMap.keySet();
for (ThreadInfo threadInfo : allThreads) {
Thread.State state = threadInfo.getThreadState();
if (state == Thread.State.BLOCKED && !knownDeadlockedThreads.contains(threadInfo.getThreadId())) {
for (LinkedHashSet cycle : cycles) {
if (cycle.contains(threadInfoMap.get(Long.valueOf(threadInfo.getLockOwnerId())))) {
LinkedHashSet chain = new LinkedHashSet<>();
for (ThreadInfo node = threadInfo; !chain.contains(node); node = threadInfoMap.get(Long.valueOf(node.getLockOwnerId())))
chain.add(node);
deadlockChain.add(chain);
}
}
}
}
return deadlockChain;
}
private ImmutableMap createThreadInfoMap(long threadIds[]) {
ThreadInfo threadInfos[] = threadBean.getThreadInfo(threadIds);
ImmutableMap.Builder threadInfoMap = ImmutableMap.builder();
for (ThreadInfo threadInfo : threadInfos) {
threadInfoMap.put(threadInfo.getThreadId(), threadInfo);
}
return threadInfoMap.build();
}
public static class Deadlock {
private final ThreadInfo members[];
private final String description;
private final ImmutableSet memberIds;
public Deadlock(ThreadInfo[] members) {
this.members = members;
ImmutableSet.Builder builder = ImmutableSet.builder();
StringBuilder sb = new StringBuilder();
for (int x = 0; x < members.length; x++) {
ThreadInfo ti = members[x];
sb.append(ti.getThreadName());
if (x < members.length)
sb.append(" > ");
if (x == members.length - 1)
sb.append(ti.getLockOwnerName());
builder.add(ti.getThreadId());
}
this.description = sb.toString();
this.memberIds = builder.build();
}
public ThreadInfo[] members() {
return members;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Deadlock deadlock = (Deadlock) o;
if (memberIds != null ? !memberIds.equals(deadlock.memberIds) : deadlock.memberIds != null) return false;
return true;
}
@Override
public int hashCode() {
int result = members != null ? Arrays.hashCode(members) : 0;
result = 31 * result + (description != null ? description.hashCode() : 0);
result = 31 * result + (memberIds != null ? memberIds.hashCode() : 0);
return result;
}
@Override
public String toString() {
return description;
}
}
}