home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / management / ThreadImpl.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  5.0 KB  |  293 lines
  1. package sun.management;
  2.  
  3. import java.lang.management.ThreadInfo;
  4. import java.lang.management.ThreadMXBean;
  5.  
  6. class ThreadImpl implements ThreadMXBean {
  7.    private final VMManagement jvm;
  8.    private boolean contentionMonitoringEnabled = false;
  9.    private boolean cpuTimeEnabled;
  10.  
  11.    ThreadImpl(VMManagement var1) {
  12.       this.jvm = var1;
  13.       this.cpuTimeEnabled = this.jvm.isThreadCpuTimeEnabled();
  14.    }
  15.  
  16.    public int getThreadCount() {
  17.       return this.jvm.getLiveThreadCount();
  18.    }
  19.  
  20.    public int getPeakThreadCount() {
  21.       return this.jvm.getPeakThreadCount();
  22.    }
  23.  
  24.    public long getTotalStartedThreadCount() {
  25.       return this.jvm.getTotalThreadCount();
  26.    }
  27.  
  28.    public int getDaemonThreadCount() {
  29.       return this.jvm.getDaemonThreadCount();
  30.    }
  31.  
  32.    public boolean isThreadContentionMonitoringSupported() {
  33.       return this.jvm.isThreadContentionMonitoringSupported();
  34.    }
  35.  
  36.    public synchronized boolean isThreadContentionMonitoringEnabled() {
  37.       if (!this.isThreadContentionMonitoringSupported()) {
  38.          throw new UnsupportedOperationException("Thread contention monitoring is not supported.");
  39.       } else {
  40.          return this.contentionMonitoringEnabled;
  41.       }
  42.    }
  43.  
  44.    public boolean isThreadCpuTimeSupported() {
  45.       return this.jvm.isOtherThreadCpuTimeSupported();
  46.    }
  47.  
  48.    public boolean isCurrentThreadCpuTimeSupported() {
  49.       return this.jvm.isCurrentThreadCpuTimeSupported();
  50.    }
  51.  
  52.    public boolean isThreadCpuTimeEnabled() {
  53.       if (!this.isThreadCpuTimeSupported() && !this.isCurrentThreadCpuTimeSupported()) {
  54.          throw new UnsupportedOperationException("Thread CPU time measurement is not supported");
  55.       } else {
  56.          return this.cpuTimeEnabled;
  57.       }
  58.    }
  59.  
  60.    public long[] getAllThreadIds() {
  61.       ManagementFactory.checkMonitorAccess();
  62.       Thread[] var1 = getThreads();
  63.       int var2 = var1.length;
  64.       long[] var3 = new long[var2];
  65.  
  66.       for(int var4 = 0; var4 < var2; ++var4) {
  67.          Thread var5 = var1[var4];
  68.          var3[var4] = var5.getId();
  69.       }
  70.  
  71.       return var3;
  72.    }
  73.  
  74.    public ThreadInfo getThreadInfo(long var1) {
  75.       if (var1 <= 0L) {
  76.          throw new IllegalArgumentException("Invalid thread ID parameter: " + var1);
  77.       } else {
  78.          long[] var3 = new long[]{var1};
  79.          ThreadInfo[] var4 = this.getThreadInfo(var3, 0);
  80.          return var4[0];
  81.       }
  82.    }
  83.  
  84.    public ThreadInfo getThreadInfo(long var1, int var3) {
  85.       if (var1 <= 0L) {
  86.          throw new IllegalArgumentException("Invalid thread ID parameter: " + var1);
  87.       } else if (var3 < 0) {
  88.          throw new IllegalArgumentException("Invalid maxDepth parameter: " + var3);
  89.       } else {
  90.          long[] var4 = new long[]{var1};
  91.          ThreadInfo[] var5 = this.getThreadInfo(var4, var3);
  92.          return var5[0];
  93.       }
  94.    }
  95.  
  96.    public ThreadInfo[] getThreadInfo(long[] var1) {
  97.       return this.getThreadInfo(var1, 0);
  98.    }
  99.  
  100.    public ThreadInfo[] getThreadInfo(long[] var1, int var2) {
  101.       if (var1 == null) {
  102.          throw new NullPointerException("Null ids parameter.");
  103.       } else if (var2 < 0) {
  104.          throw new IllegalArgumentException("Invalid maxDepth parameter: " + var2);
  105.       } else {
  106.          ManagementFactory.checkMonitorAccess();
  107.          ThreadInfo[] var3 = new ThreadInfo[var1.length];
  108.          if (var2 == Integer.MAX_VALUE) {
  109.             getThreadInfo0(var1, -1, var3);
  110.          } else {
  111.             getThreadInfo0(var1, var2, var3);
  112.          }
  113.  
  114.          return var3;
  115.       }
  116.    }
  117.  
  118.    public void setThreadContentionMonitoringEnabled(boolean var1) {
  119.       if (!this.isThreadContentionMonitoringSupported()) {
  120.          throw new UnsupportedOperationException("Thread contention monitoring is not supported");
  121.       } else {
  122.          ManagementFactory.checkControlAccess();
  123.          synchronized(this) {
  124.             if (this.contentionMonitoringEnabled != var1) {
  125.                if (var1) {
  126.                   resetContentionTimes0(0L);
  127.                }
  128.  
  129.                setThreadContentionMonitoringEnabled0(var1);
  130.                this.contentionMonitoringEnabled = var1;
  131.             }
  132.  
  133.          }
  134.       }
  135.    }
  136.  
  137.    public long getCurrentThreadCpuTime() {
  138.       if (!this.isCurrentThreadCpuTimeSupported()) {
  139.          throw new UnsupportedOperationException("Current thread CPU time measurement is not supported.");
  140.       } else {
  141.          return !this.isThreadCpuTimeEnabled() ? -1L : getThreadTotalCpuTime0(0L);
  142.       }
  143.    }
  144.  
  145.    public long getThreadCpuTime(long var1) {
  146.       if (!this.isThreadCpuTimeSupported() && !this.isCurrentThreadCpuTimeSupported()) {
  147.          throw new UnsupportedOperationException("Thread CPU Time Measurement is not supported.");
  148.       } else if (!this.isThreadCpuTimeSupported() && var1 != Thread.currentThread().getId()) {
  149.          throw new UnsupportedOperationException("Thread CPU Time Measurement is only supported for the current thread.");
  150.       } else if (var1 <= 0L) {
  151.          throw new IllegalArgumentException("Invalid thread ID parameter: " + var1);
  152.       } else if (!this.isThreadCpuTimeEnabled()) {
  153.          return -1L;
  154.       } else {
  155.          return var1 == Thread.currentThread().getId() ? getThreadTotalCpuTime0(0L) : getThreadTotalCpuTime0(var1);
  156.       }
  157.    }
  158.  
  159.    public long getCurrentThreadUserTime() {
  160.       if (!this.isCurrentThreadCpuTimeSupported()) {
  161.          throw new UnsupportedOperationException("Current thread CPU time measurement is not supported.");
  162.       } else {
  163.          return !this.isThreadCpuTimeEnabled() ? -1L : getThreadUserCpuTime0(0L);
  164.       }
  165.    }
  166.  
  167.    public long getThreadUserTime(long var1) {
  168.       if (!this.isThreadCpuTimeSupported() && !this.isCurrentThreadCpuTimeSupported()) {
  169.          throw new UnsupportedOperationException("Thread CPU time measurement is not supported.");
  170.       } else if (!this.isThreadCpuTimeSupported() && var1 != Thread.currentThread().getId()) {
  171.          throw new UnsupportedOperationException("Thread CPU time measurement is only supported for the current thread.");
  172.       } else if (var1 <= 0L) {
  173.          throw new IllegalArgumentException("Invalid thread ID parameter: " + var1);
  174.       } else if (!this.isThreadCpuTimeEnabled()) {
  175.          return -1L;
  176.       } else {
  177.          return var1 == Thread.currentThread().getId() ? getThreadUserCpuTime0(0L) : getThreadUserCpuTime0(var1);
  178.       }
  179.    }
  180.  
  181.    public void setThreadCpuTimeEnabled(boolean var1) {
  182.       if (!this.isThreadCpuTimeSupported() && !this.isCurrentThreadCpuTimeSupported()) {
  183.          throw new UnsupportedOperationException("Thread CPU time measurement is not supported");
  184.       } else {
  185.          ManagementFactory.checkControlAccess();
  186.          synchronized(this) {
  187.             if (this.cpuTimeEnabled != var1) {
  188.                setThreadCpuTimeEnabled0(var1);
  189.                this.cpuTimeEnabled = var1;
  190.             }
  191.  
  192.          }
  193.       }
  194.    }
  195.  
  196.    public long[] findMonitorDeadlockedThreads() {
  197.       ManagementFactory.checkMonitorAccess();
  198.       Thread[] var1 = findMonitorDeadlockedThreads0();
  199.       if (var1 == null) {
  200.          return null;
  201.       } else {
  202.          long[] var2 = new long[var1.length];
  203.  
  204.          for(int var3 = 0; var3 < var1.length; ++var3) {
  205.             Thread var4 = var1[var3];
  206.             var2[var3] = var4.getId();
  207.          }
  208.  
  209.          return var2;
  210.       }
  211.    }
  212.  
  213.    public long[] findDeadlockedThreads() {
  214.       if (!this.isSynchronizerUsageSupported()) {
  215.          throw new UnsupportedOperationException("Monitoring of Synchronizer Usage is not supported.");
  216.       } else {
  217.          ManagementFactory.checkMonitorAccess();
  218.          Thread[] var1 = findDeadlockedThreads0();
  219.          if (var1 == null) {
  220.             return null;
  221.          } else {
  222.             long[] var2 = new long[var1.length];
  223.  
  224.             for(int var3 = 0; var3 < var1.length; ++var3) {
  225.                Thread var4 = var1[var3];
  226.                var2[var3] = var4.getId();
  227.             }
  228.  
  229.             return var2;
  230.          }
  231.       }
  232.    }
  233.  
  234.    public void resetPeakThreadCount() {
  235.       ManagementFactory.checkControlAccess();
  236.       resetPeakThreadCount0();
  237.    }
  238.  
  239.    public boolean isObjectMonitorUsageSupported() {
  240.       return this.jvm.isObjectMonitorUsageSupported();
  241.    }
  242.  
  243.    public boolean isSynchronizerUsageSupported() {
  244.       return this.jvm.isSynchronizerUsageSupported();
  245.    }
  246.  
  247.    public ThreadInfo[] getThreadInfo(long[] var1, boolean var2, boolean var3) {
  248.       if (var1 == null) {
  249.          throw new NullPointerException("Null ids parameter.");
  250.       } else if (var2 && !this.isObjectMonitorUsageSupported()) {
  251.          throw new UnsupportedOperationException("Monitoring of Object Monitor Usage is not supported.");
  252.       } else if (var3 && !this.isSynchronizerUsageSupported()) {
  253.          throw new UnsupportedOperationException("Monitoring of Synchronizer Usage is not supported.");
  254.       } else {
  255.          ManagementFactory.checkMonitorAccess();
  256.          return dumpThreads0(var1, var2, var3);
  257.       }
  258.    }
  259.  
  260.    public ThreadInfo[] dumpAllThreads(boolean var1, boolean var2) {
  261.       if (var1 && !this.isObjectMonitorUsageSupported()) {
  262.          throw new UnsupportedOperationException("Monitoring of Object Monitor Usage is not supported.");
  263.       } else if (var2 && !this.isSynchronizerUsageSupported()) {
  264.          throw new UnsupportedOperationException("Monitoring of Synchronizer Usage is not supported.");
  265.       } else {
  266.          ManagementFactory.checkMonitorAccess();
  267.          return dumpThreads0((long[])null, var1, var2);
  268.       }
  269.    }
  270.  
  271.    private static native Thread[] getThreads();
  272.  
  273.    private static native void getThreadInfo0(long[] var0, int var1, ThreadInfo[] var2);
  274.  
  275.    private static native long getThreadTotalCpuTime0(long var0);
  276.  
  277.    private static native long getThreadUserCpuTime0(long var0);
  278.  
  279.    private static native void setThreadCpuTimeEnabled0(boolean var0);
  280.  
  281.    private static native void setThreadContentionMonitoringEnabled0(boolean var0);
  282.  
  283.    private static native Thread[] findMonitorDeadlockedThreads0();
  284.  
  285.    private static native Thread[] findDeadlockedThreads0();
  286.  
  287.    private static native void resetPeakThreadCount0();
  288.  
  289.    private static native ThreadInfo[] dumpThreads0(long[] var0, boolean var1, boolean var2);
  290.  
  291.    private static native void resetContentionTimes0(long var0);
  292. }
  293.