home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / lang / ThreadGroup.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  5.6 KB  |  546 lines
  1. package java.lang;
  2.  
  3. import java.io.PrintStream;
  4. import sun.misc.VM;
  5.  
  6. public class ThreadGroup {
  7.    ThreadGroup parent;
  8.    String name;
  9.    int maxPriority;
  10.    boolean destroyed;
  11.    boolean daemon;
  12.    boolean vmAllowSuspension;
  13.    int nthreads;
  14.    Thread[] threads;
  15.    int ngroups;
  16.    ThreadGroup[] groups;
  17.  
  18.    private ThreadGroup() {
  19.       this.name = "system";
  20.       this.maxPriority = 10;
  21.    }
  22.  
  23.    public ThreadGroup(String var1) {
  24.       this(Thread.currentThread().getThreadGroup(), var1);
  25.    }
  26.  
  27.    public ThreadGroup(ThreadGroup var1, String var2) {
  28.       if (var1 == null) {
  29.          throw new NullPointerException();
  30.       } else {
  31.          var1.checkAccess();
  32.          this.name = var2;
  33.          this.maxPriority = var1.maxPriority;
  34.          this.daemon = var1.daemon;
  35.          this.vmAllowSuspension = var1.vmAllowSuspension;
  36.          this.parent = var1;
  37.          var1.add(this);
  38.       }
  39.    }
  40.  
  41.    public final String getName() {
  42.       return this.name;
  43.    }
  44.  
  45.    public final ThreadGroup getParent() {
  46.       if (this.parent != null) {
  47.          this.parent.checkAccess();
  48.       }
  49.  
  50.       return this.parent;
  51.    }
  52.  
  53.    public final int getMaxPriority() {
  54.       return this.maxPriority;
  55.    }
  56.  
  57.    public final boolean isDaemon() {
  58.       return this.daemon;
  59.    }
  60.  
  61.    public synchronized boolean isDestroyed() {
  62.       return this.destroyed;
  63.    }
  64.  
  65.    public final void setDaemon(boolean var1) {
  66.       this.checkAccess();
  67.       this.daemon = var1;
  68.    }
  69.  
  70.    public final void setMaxPriority(int var1) {
  71.       int var2;
  72.       ThreadGroup[] var3;
  73.       synchronized(this) {
  74.          this.checkAccess();
  75.          if (var1 < 1) {
  76.             this.maxPriority = 1;
  77.          } else if (var1 < this.maxPriority) {
  78.             this.maxPriority = var1;
  79.          }
  80.  
  81.          var2 = this.ngroups;
  82.          if (this.groups != null) {
  83.             var3 = new ThreadGroup[var2];
  84.             System.arraycopy(this.groups, 0, var3, 0, var2);
  85.          } else {
  86.             var3 = null;
  87.          }
  88.       }
  89.  
  90.       for(int var5 = 0; var5 < var2; ++var5) {
  91.          var3[var5].setMaxPriority(var1);
  92.       }
  93.  
  94.    }
  95.  
  96.    public final boolean parentOf(ThreadGroup var1) {
  97.       while(var1 != null) {
  98.          if (var1 == this) {
  99.             return true;
  100.          }
  101.  
  102.          var1 = var1.parent;
  103.       }
  104.  
  105.       return false;
  106.    }
  107.  
  108.    public final void checkAccess() {
  109.       SecurityManager var1 = System.getSecurityManager();
  110.       if (var1 != null) {
  111.          var1.checkAccess(this);
  112.       }
  113.  
  114.    }
  115.  
  116.    public int activeCount() {
  117.       int var1;
  118.       int var2;
  119.       ThreadGroup[] var3;
  120.       synchronized(this) {
  121.          if (this.destroyed) {
  122.             byte var8 = 0;
  123.             return var8;
  124.          }
  125.  
  126.          var1 = this.nthreads;
  127.          var2 = this.ngroups;
  128.          if (this.groups != null) {
  129.             var3 = new ThreadGroup[var2];
  130.             System.arraycopy(this.groups, 0, var3, 0, var2);
  131.          } else {
  132.             var3 = null;
  133.          }
  134.       }
  135.  
  136.       for(int var5 = 0; var5 < var2; ++var5) {
  137.          var1 += var3[var5].activeCount();
  138.       }
  139.  
  140.       return var1;
  141.    }
  142.  
  143.    public int enumerate(Thread[] var1) {
  144.       this.checkAccess();
  145.       return this.enumerate((Thread[])var1, 0, true);
  146.    }
  147.  
  148.    public int enumerate(Thread[] var1, boolean var2) {
  149.       this.checkAccess();
  150.       return this.enumerate((Thread[])var1, 0, var2);
  151.    }
  152.  
  153.    private int enumerate(Thread[] var1, int var2, boolean var3) {
  154.       int var4 = 0;
  155.       ThreadGroup[] var5 = null;
  156.       synchronized(this) {
  157.          if (this.destroyed) {
  158.             byte var12 = 0;
  159.             return var12;
  160.          }
  161.  
  162.          int var7 = this.nthreads;
  163.          if (var7 > var1.length - var2) {
  164.             var7 = var1.length - var2;
  165.          }
  166.  
  167.          for(int var8 = 0; var8 < var7; ++var8) {
  168.             if (this.threads[var8].isAlive()) {
  169.                var1[var2++] = this.threads[var8];
  170.             }
  171.          }
  172.  
  173.          if (var3) {
  174.             var4 = this.ngroups;
  175.             if (this.groups != null) {
  176.                var5 = new ThreadGroup[var4];
  177.                System.arraycopy(this.groups, 0, var5, 0, var4);
  178.             } else {
  179.                var5 = null;
  180.             }
  181.          }
  182.       }
  183.  
  184.       if (var3) {
  185.          for(int var11 = 0; var11 < var4; ++var11) {
  186.             var2 = var5[var11].enumerate(var1, var2, true);
  187.          }
  188.       }
  189.  
  190.       return var2;
  191.    }
  192.  
  193.    public int activeGroupCount() {
  194.       int var1;
  195.       ThreadGroup[] var2;
  196.       synchronized(this) {
  197.          if (this.destroyed) {
  198.             byte var7 = 0;
  199.             return var7;
  200.          }
  201.  
  202.          var1 = this.ngroups;
  203.          if (this.groups != null) {
  204.             var2 = new ThreadGroup[var1];
  205.             System.arraycopy(this.groups, 0, var2, 0, var1);
  206.          } else {
  207.             var2 = null;
  208.          }
  209.       }
  210.  
  211.       int var4 = var1;
  212.  
  213.       for(int var5 = 0; var5 < var1; ++var5) {
  214.          var4 += var2[var5].activeGroupCount();
  215.       }
  216.  
  217.       return var4;
  218.    }
  219.  
  220.    public int enumerate(ThreadGroup[] var1) {
  221.       this.checkAccess();
  222.       return this.enumerate((ThreadGroup[])var1, 0, true);
  223.    }
  224.  
  225.    public int enumerate(ThreadGroup[] var1, boolean var2) {
  226.       this.checkAccess();
  227.       return this.enumerate((ThreadGroup[])var1, 0, var2);
  228.    }
  229.  
  230.    private int enumerate(ThreadGroup[] var1, int var2, boolean var3) {
  231.       int var4 = 0;
  232.       ThreadGroup[] var5 = null;
  233.       synchronized(this) {
  234.          if (this.destroyed) {
  235.             byte var11 = 0;
  236.             return var11;
  237.          }
  238.  
  239.          int var7 = this.ngroups;
  240.          if (var7 > var1.length - var2) {
  241.             var7 = var1.length - var2;
  242.          }
  243.  
  244.          if (var7 > 0) {
  245.             System.arraycopy(this.groups, 0, var1, var2, var7);
  246.             var2 += var7;
  247.          }
  248.  
  249.          if (var3) {
  250.             var4 = this.ngroups;
  251.             if (this.groups != null) {
  252.                var5 = new ThreadGroup[var4];
  253.                System.arraycopy(this.groups, 0, var5, 0, var4);
  254.             } else {
  255.                var5 = null;
  256.             }
  257.          }
  258.       }
  259.  
  260.       if (var3) {
  261.          for(int var10 = 0; var10 < var4; ++var10) {
  262.             var2 = var5[var10].enumerate(var1, var2, true);
  263.          }
  264.       }
  265.  
  266.       return var2;
  267.    }
  268.  
  269.    public final void stop() {
  270.       if (this.stopOrSuspend(false)) {
  271.          Thread.currentThread().stop();
  272.       }
  273.  
  274.    }
  275.  
  276.    public final void interrupt() {
  277.       int var1;
  278.       ThreadGroup[] var2;
  279.       synchronized(this) {
  280.          this.checkAccess();
  281.  
  282.          for(int var4 = 0; var4 < this.nthreads; ++var4) {
  283.             this.threads[var4].interrupt();
  284.          }
  285.  
  286.          var1 = this.ngroups;
  287.          if (this.groups != null) {
  288.             var2 = new ThreadGroup[var1];
  289.             System.arraycopy(this.groups, 0, var2, 0, var1);
  290.          } else {
  291.             var2 = null;
  292.          }
  293.       }
  294.  
  295.       for(int var7 = 0; var7 < var1; ++var7) {
  296.          var2[var7].interrupt();
  297.       }
  298.  
  299.    }
  300.  
  301.    public final void suspend() {
  302.       if (this.stopOrSuspend(true)) {
  303.          Thread.currentThread().suspend();
  304.       }
  305.  
  306.    }
  307.  
  308.    private boolean stopOrSuspend(boolean var1) {
  309.       boolean var2 = false;
  310.       Thread var3 = Thread.currentThread();
  311.       ThreadGroup[] var5 = null;
  312.       int var4;
  313.       synchronized(this) {
  314.          this.checkAccess();
  315.  
  316.          for(int var7 = 0; var7 < this.nthreads; ++var7) {
  317.             if (this.threads[var7] == var3) {
  318.                var2 = true;
  319.             } else if (var1) {
  320.                this.threads[var7].suspend();
  321.             } else {
  322.                this.threads[var7].stop();
  323.             }
  324.          }
  325.  
  326.          var4 = this.ngroups;
  327.          if (this.groups != null) {
  328.             var5 = new ThreadGroup[var4];
  329.             System.arraycopy(this.groups, 0, var5, 0, var4);
  330.          }
  331.       }
  332.  
  333.       for(int var10 = 0; var10 < var4; ++var10) {
  334.          var2 = var5[var10].stopOrSuspend(var1) || var2;
  335.       }
  336.  
  337.       return var2;
  338.    }
  339.  
  340.    public final void resume() {
  341.       int var1;
  342.       ThreadGroup[] var2;
  343.       synchronized(this) {
  344.          this.checkAccess();
  345.  
  346.          for(int var4 = 0; var4 < this.nthreads; ++var4) {
  347.             this.threads[var4].resume();
  348.          }
  349.  
  350.          var1 = this.ngroups;
  351.          if (this.groups != null) {
  352.             var2 = new ThreadGroup[var1];
  353.             System.arraycopy(this.groups, 0, var2, 0, var1);
  354.          } else {
  355.             var2 = null;
  356.          }
  357.       }
  358.  
  359.       for(int var7 = 0; var7 < var1; ++var7) {
  360.          var2[var7].resume();
  361.       }
  362.  
  363.    }
  364.  
  365.    public final void destroy() {
  366.       int var1;
  367.       ThreadGroup[] var2;
  368.       synchronized(this) {
  369.          this.checkAccess();
  370.          if (this.destroyed || this.nthreads > 0) {
  371.             throw new IllegalThreadStateException();
  372.          }
  373.  
  374.          var1 = this.ngroups;
  375.          if (this.groups != null) {
  376.             var2 = new ThreadGroup[var1];
  377.             System.arraycopy(this.groups, 0, var2, 0, var1);
  378.          } else {
  379.             var2 = null;
  380.          }
  381.  
  382.          if (this.parent != null) {
  383.             this.destroyed = true;
  384.             this.ngroups = 0;
  385.             this.groups = null;
  386.             this.nthreads = 0;
  387.             this.threads = null;
  388.          }
  389.       }
  390.  
  391.       for(int var4 = 0; var4 < var1; ++var4) {
  392.          var2[var4].destroy();
  393.       }
  394.  
  395.       if (this.parent != null) {
  396.          this.parent.remove(this);
  397.       }
  398.  
  399.    }
  400.  
  401.    private final void add(ThreadGroup var1) {
  402.       synchronized(this) {
  403.          if (this.destroyed) {
  404.             throw new IllegalThreadStateException();
  405.          } else {
  406.             if (this.groups == null) {
  407.                this.groups = new ThreadGroup[4];
  408.             } else if (this.ngroups == this.groups.length) {
  409.                ThreadGroup[] var3 = new ThreadGroup[this.ngroups * 2];
  410.                System.arraycopy(this.groups, 0, var3, 0, this.ngroups);
  411.                this.groups = var3;
  412.             }
  413.  
  414.             this.groups[this.ngroups] = var1;
  415.             ++this.ngroups;
  416.          }
  417.       }
  418.    }
  419.  
  420.    private void remove(ThreadGroup var1) {
  421.       synchronized(this) {
  422.          if (!this.destroyed) {
  423.             for(int var3 = 0; var3 < this.ngroups; ++var3) {
  424.                if (this.groups[var3] == var1) {
  425.                   --this.ngroups;
  426.                   System.arraycopy(this.groups, var3 + 1, this.groups, var3, this.ngroups - var3);
  427.                   this.groups[this.ngroups] = null;
  428.                   break;
  429.                }
  430.             }
  431.  
  432.             if (this.nthreads == 0) {
  433.                this.notifyAll();
  434.             }
  435.  
  436.             if (this.daemon && this.nthreads == 0 && this.ngroups == 0) {
  437.                this.destroy();
  438.             }
  439.  
  440.          }
  441.       }
  442.    }
  443.  
  444.    void add(Thread var1) {
  445.       synchronized(this) {
  446.          if (this.destroyed) {
  447.             throw new IllegalThreadStateException();
  448.          } else {
  449.             if (this.threads == null) {
  450.                this.threads = new Thread[4];
  451.             } else if (this.nthreads == this.threads.length) {
  452.                Thread[] var3 = new Thread[this.nthreads * 2];
  453.                System.arraycopy(this.threads, 0, var3, 0, this.nthreads);
  454.                this.threads = var3;
  455.             }
  456.  
  457.             this.threads[this.nthreads] = var1;
  458.             ++this.nthreads;
  459.          }
  460.       }
  461.    }
  462.  
  463.    void remove(Thread var1) {
  464.       synchronized(this) {
  465.          if (!this.destroyed) {
  466.             for(int var3 = 0; var3 < this.nthreads; ++var3) {
  467.                if (this.threads[var3] == var1) {
  468.                   System.arraycopy(this.threads, var3 + 1, this.threads, var3, --this.nthreads - var3);
  469.                   this.threads[this.nthreads] = null;
  470.                   break;
  471.                }
  472.             }
  473.  
  474.             if (this.nthreads == 0) {
  475.                this.notifyAll();
  476.             }
  477.  
  478.             if (this.daemon && this.nthreads == 0 && this.ngroups == 0) {
  479.                this.destroy();
  480.             }
  481.  
  482.          }
  483.       }
  484.    }
  485.  
  486.    public void list() {
  487.       this.list(System.out, 0);
  488.    }
  489.  
  490.    void list(PrintStream var1, int var2) {
  491.       int var3;
  492.       ThreadGroup[] var4;
  493.       synchronized(this) {
  494.          for(int var6 = 0; var6 < var2; ++var6) {
  495.             var1.print(" ");
  496.          }
  497.  
  498.          var1.println(this);
  499.          var2 += 4;
  500.  
  501.          for(int var7 = 0; var7 < this.nthreads; ++var7) {
  502.             for(int var8 = 0; var8 < var2; ++var8) {
  503.                var1.print(" ");
  504.             }
  505.  
  506.             var1.println(this.threads[var7]);
  507.          }
  508.  
  509.          var3 = this.ngroups;
  510.          if (this.groups != null) {
  511.             var4 = new ThreadGroup[var3];
  512.             System.arraycopy(this.groups, 0, var4, 0, var3);
  513.          } else {
  514.             var4 = null;
  515.          }
  516.       }
  517.  
  518.       for(int var12 = 0; var12 < var3; ++var12) {
  519.          var4[var12].list(var1, var2);
  520.       }
  521.  
  522.    }
  523.  
  524.    public void uncaughtException(Thread var1, Throwable var2) {
  525.       if (this.parent != null) {
  526.          this.parent.uncaughtException(var1, var2);
  527.       } else if (!(var2 instanceof ThreadDeath)) {
  528.          var2.printStackTrace(System.err);
  529.       }
  530.  
  531.    }
  532.  
  533.    public boolean allowThreadSuspension(boolean var1) {
  534.       this.vmAllowSuspension = var1;
  535.       if (!var1) {
  536.          VM.unsuspendSomeThreads();
  537.       }
  538.  
  539.       return true;
  540.    }
  541.  
  542.    public String toString() {
  543.       return this.getClass().getName() + "[name=" + this.getName() + ",maxpri=" + this.maxPriority + "]";
  544.    }
  545. }
  546.