线程的优先级

线程的优先级（Priority）汇报调试措施该线程的重要水平有多大。假如有大量线程都被堵塞，都在等待运行，调试措施会首先运行具有最高优先级的谁人线程。然而，这并不暗示优先级较低的线程不会运行（换言之，不会因为存在优先级而导致死锁）。若线程的优先级较低，只不外暗示它被准许运行的时机小一些罢了。
可用getPriority()要领读取一个线程的优先级，并用setPriority()改变它。在下面这个措施片中，各人会发明计数器的计数速度慢了下来，因为它们关联的线程分派了较低的优先级：
 

//: Counter5.java
// Adjusting the priorities of threads
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class Ticker2 extends Thread {
  private Button 
    b = new Button("Toggle"),
    incPriority = new Button("up"),
    decPriority = new Button("down");
  private TextField 
    t = new TextField(10),
    pr = new TextField(3); // Display priority
  private int count = 0;
  private boolean runFlag = true;
  public Ticker2(Container c) {
    b.addActionListener(new ToggleL());
    incPriority.addActionListener(new UpL());
    decPriority.addActionListener(new DownL());
    Panel p = new Panel();
    p.add(t);
    p.add(pr);
    p.add(b);
    p.add(incPriority);
    p.add(decPriority);
    c.add(p);
  }
  class ToggleL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      runFlag = !runFlag;
    }
  }
  class UpL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      int newPriority = getPriority() + 1;
      if(newPriority > Thread.MAX_PRIORITY)
        newPriority = Thread.MAX_PRIORITY;
      setPriority(newPriority);
    }
  }
  class DownL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      int newPriority = getPriority() - 1;
      if(newPriority < Thread.MIN_PRIORITY)
        newPriority = Thread.MIN_PRIORITY;
      setPriority(newPriority);
    }
  }
  public void run() {
    while (true) {
      if(runFlag) {
        t.setText(Integer.toString(count++));
        pr.setText(
          Integer.toString(getPriority()));
      }
      yield();
    }
  }
}

public class Counter5 extends Applet {
  private Button 
    start = new Button("Start"),
    upMax = new Button("Inc Max Priority"),
    downMax = new Button("Dec Max Priority");
  private boolean started = false;
  private static final int SIZE = 10;
  private Ticker2[] s = new Ticker2[SIZE];
  private TextField mp = new TextField(3);
  public void init() {
    for(int i = 0; i < s.length; i++)
      s[i] = new Ticker2(this);
    add(new Label("MAX_PRIORITY = "
      + Thread.MAX_PRIORITY));
    add(new Label("MIN_PRIORITY = "
      + Thread.MIN_PRIORITY));
    add(new Label("Group Max Priority = "));
    add(mp); 
    add(start);
    add(upMax); add(downMax);
    start.addActionListener(new StartL());
    upMax.addActionListener(new UpMaxL());
    downMax.addActionListener(new DownMaxL());
    showMaxPriority();
    // Recursively display parent thread groups:
    ThreadGroup parent = 
      s[0].getThreadGroup().getParent();
    while(parent != null) {
      add(new Label(
        "Parent threadgroup max priority = "
        + parent.getMaxPriority()));
      parent = parent.getParent();
    }
  }
  public void showMaxPriority() {
    mp.setText(Integer.toString(
      s[0].getThreadGroup().getMaxPriority()));
  }
  class StartL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      if(!started) {
        started = true;
        for(int i = 0; i < s.length; i++)
          s[i].start();
      }
    }
  }
  class UpMaxL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      int maxp = 
        s[0].getThreadGroup().getMaxPriority();
      if(++maxp > Thread.MAX_PRIORITY)
        maxp = Thread.MAX_PRIORITY;
      s[0].getThreadGroup().setMaxPriority(maxp);
      showMaxPriority();
    }
  }
  class DownMaxL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      int maxp = 
        s[0].getThreadGroup().getMaxPriority();
      if(--maxp < Thread.MIN_PRIORITY)
        maxp = Thread.MIN_PRIORITY;
      s[0].getThreadGroup().setMaxPriority(maxp);
      showMaxPriority();
    }
  }
  public static void main(String[] args) {
    Counter5 applet = new Counter5();
    Frame aFrame = new Frame("Counter5");
    aFrame.addWindowListener(
      new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          System.exit(0);
        }
      });
    aFrame.add(applet, BorderLayout.CENTER);
    aFrame.setSize(300, 600);
    applet.init();
    applet.start();
    aFrame.setVisible(true);
  }
} ///:~

Ticker回收本章前面结构好的形式，但有一个特另外TextField（文本字段），用于显示线程的优先级；以及两个特另外按钮，用于工钱提高及低落优先级。
也要留意yield()的用法，它将节制权自动返回给调试措施（机制）。若不举办这样的处理惩罚，多线程机制仍会事情，但我们会发明它的运行速度慢了下来（试试删去对yield()的挪用）。亦可挪用sleep()，但假使那样做，计数频率就会改由sleep()的一连时间节制，而不是优先级。
Counter5中的init()建设了由10个Ticker2组成的一个数组；它们的按钮以及输入字段（文本字段）由Ticker2构建器置入窗体。Counter5增加了新的按钮，用于启动一切，以及用于提高和低落线程组的最大优先级。除此以外，尚有一些标签用于显示一个线程可以回收的最大及最小优先级；以及一个非凡的文本字段，用于显示线程组的最大优先级（在下一节里，我们将全面接头线程组的问题）。最后，父线程组的优先级也作为标签显示出来。
按下“up”（上）或“down”（下）按钮的时候，会先取得Ticker2当前的优先级，然后相应地提高可能低落。
运行该措施时，我们可留意到几件工作。首先，线程组的默认优先级是5。纵然在启动线程之前（可能在建设线程之前，这要求对代码举办适当的修改）将最大优先级降到5以下，每个线程城市有一个5的默认优先级。
最简朴的测试是获取一个计数器，将它的优先级低落至1，此时应调查到它的计数频率显著放慢。此刻试着再次提高优先级，可以升高回线程组的优先级，但不能再高了。此刻将线程组的优先级低落两次。线程的优先级不会改变，但假使试图提高可能低落它，就会发明这个优先级自动酿成线程组的优先级。另外，新线程仍然具有一个默认优先级，纵然它比组的优先级还要高（换句话说，不要指望操作组优先级来防备新线程拥有比现有的更高的优先级）。
最后，试着提高组的最大优先级。可以发明，这样做是没有结果的。我们只能淘汰线程组的最大优先级，而不能增大它。