static  void clearCache() 
{
    CONSTRUCTOR_CACHE.clear();
}

 static int getCacheSize() 
{
    return CONSTRUCTOR_CACHE.size();
}

 public static synchronized  void logThreadInfo(Log log,
    String title,
    long minInterval) 
{
    
    if (log.isInfoEnabled()) {
      long now = System.currentTimeMillis();
      if (now - previousLogTime  >= minInterval * 1000) {
        previousLogTime = now;
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        printThreadInfo(new PrintWriter(buffer), title);
        log.info(buffer.toString());
      }
    }
}

Log the current thread stacks at INFO level.

 public static Object newInstance(Class theClass,
    Configuration conf) 
{
    Object result;
    try {
      Constructor meth = CONSTRUCTOR_CACHE.get(theClass);
      if (meth == null) {
        meth = theClass.getDeclaredConstructor(emptyArray);
        meth.setAccessible(true);
        CONSTRUCTOR_CACHE.put(theClass, meth);
      }
      result = meth.newInstance();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    setConf(result, conf);
    return result;
}

Create an object for the given class and initialize it from conf

 public static  void printThreadInfo(PrintWriter stream,
    String title) 
{
    final int STACK_DEPTH = 20;
    boolean contention = threadBean.isThreadContentionMonitoringEnabled();
    long[] threadIds = threadBean.getAllThreadIds();
    stream.println("Process Thread Dump: " + title);
    stream.println(threadIds.length + " active threads");
    for (long tid: threadIds) {
      ThreadInfo info = threadBean.getThreadInfo(tid, STACK_DEPTH);
      if (info == null) {
        stream.println("  Inactive");
        continue;
      }
      stream.println("Thread " + 
                     getTaskName(info.getThreadId(),
                                 info.getThreadName()) + ":");
      Thread.State state = info.getThreadState();
      stream.println("  State: " + state);
      stream.println("  Blocked count: " + info.getBlockedCount());
      stream.println("  Waited count: " + info.getWaitedCount());
      if (contention) {
        stream.println("  Blocked time: " + info.getBlockedTime());
        stream.println("  Waited time: " + info.getWaitedTime());
      }
      if (state == Thread.State.WAITING) {
        stream.println("  Waiting on " + info.getLockName());
      } else  if (state == Thread.State.BLOCKED) {
        stream.println("  Blocked on " + info.getLockName());
        stream.println("  Blocked by " + 
                       getTaskName(info.getLockOwnerId(),
                                   info.getLockOwnerName()));
      }
      stream.println("  Stack:");
      for (StackTraceElement frame: info.getStackTrace()) {
        stream.println("    " + frame.toString());
      }
    }
    stream.flush();
}

Print all of the thread's information and stack traces.

 public static  void setConf(Object theObject,
    Configuration conf) 
{
                       
    if (conf != null) {
      if (theObject instanceof Configurable) {
        ((Configurable) theObject).setConf(conf);
      }
      if (conf instanceof JobConf && 
          theObject instanceof JobConfigurable) {
        ((JobConfigurable)theObject).configure((JobConf) conf);
      }
    }
}

Check and set 'configuration' if necessary.

 public static  void setContentionTracing(boolean val) 
{
    
    threadBean.setThreadContentionMonitoringEnabled(val);
}