线程优先级

当程序中有多个线程存在的时候，线程和线程之间的关系并非是平等的。例如，总有一些线程是CPU消耗密集型的，也就说该线程所对应的任务是紧迫的，因此需提高这些线程的优先级来保证这些线程能够分得更多的时间片。这时肯定会出现高优先级的线程抢占低优先级线程的执行权的情况。这样一来，很有可能出现低优先级的线程长时间得不到执行的问题。要解决这个问题，就要求在那些已经设置为高优先级的线程完成了任务以后，降低它们的优先级从而使其他线程也能够得到执行。下面就介绍这些方法实现的具体步骤。

具体步骤

1 / 在程序中创建多线程

（1）通过扩展Thread类来创建多线程

假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。

// 例4.2.1  MutliThreadDemo.java
class MutliThread extends Thread
{
    private int ticket = 100; // 每一个线程都拥有100张票
    MutliThread(String name)
    {
        super(name);
    }
    public void run()
    {
        while (ticket > 0)
            System.out.println(ticket-- + "  is saled by " + currentThread().getName());
    }
}
class MutliThreadDemo
{
    public static void main(String[] args)
    {
        MutliThread m1 = new MutliThread("Window 1");
        MutliThread m2 = new MutliThread("Window 2");
        MutliThread m3 = new MutliThread("Window 3");
        m1.start();
        m2.start();
        m3.start();
    }
}

程序中定义一个线程类，它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象，并通过start()方法分别将它们启动。执行这个程序就可以看到如图4.2.1所示的结果：



从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。

可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。

（2）通过实现Runnable接口来创建多线程

同样是这个例子，能否用实现Runnable接口的方式来创建多线程以实现上述功能呢？看下面的程序，请注意和例4.2.1的区别。

// 例 4.2.2  MutliThreadDemo2.java
class MutliThread implements Runnable
{
    private int ticket = 100;
    private String name;
    MutliThread(String name)
    {
        this.name = name;
    }
    public void run()
    {
        while (ticket > 0)
            System.out.println(ticket-- + "  is saled by " + name);
    }
}
class MutliThreadDemo2
{
    public static void main(String[] args)
    {
        MutliThread m1 = new MutliThread("Window 1");
        MutliThread m2 = new MutliThread("Window 2");
        MutliThread m3 = new MutliThread("Window 3");
        Thread t1 = new Thread(m1);
        Thread t2 = new Thread(m2);
        Thread t3 = new Thread(m3);
        t1.start();
        t2.start();
        t3.start();
    }
}

该程序几乎和例4.2.1完全一样，只不过程序中MutliThread类实现了Runnable接口，主方法中三个线程是由这个实现了Runnable接口的类和Thread类共同创建的，最后也是通过start()方法将它们全部启动。


由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和例4.2.1的结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。

可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。

通过实现Runnable接口来创建多线程程序的方法其实还可以用另一种方式来编写，尽管功能相同，但却能够提供更多的选择，这种方法如下所示。

// 例4.2.3  MutliThreadDemo3.java
class MutliThread implements Runnable
{
    private int ticket = 100;
    Thread t;
    MutliThread(String name)
    {
        t = new Thread(this, name); // 创建线程
    }
    public void run()
    {
        while (ticket > 0)
            System.out.println(ticket-- + "  is saled by " + t.getName());
    }
    public void start() // 自定义start()方法来调用Thread类的start()方法
    {
        t.start();
    }
}
class MutliThreadDemo3
{
    public static void main(String args[])
    {
        MutliThread m1 = new MutliThread("Window 1");
        MutliThread m2 = new MutliThread("Window 2");
        MutliThread m3 = new MutliThread("Window 3");// 这里调用的是MutliThread类自定义的start
                                                     // ()方法而不是Thread类的start()方法
        m1.start();
        m2.start();
        m3.start();
    }
}

可以看到，程序执行的顺序是：创建MutliThread类的对象->初始化成员变量->调用构造函数->创建线程->调用MutliThread类的start()方法->启动线程->调用MutliThread类的run()方法执行线程->所有线程结束->程序执行完毕。

使用上面的这些创建多线程的方式创建的线程彼此都是独立的，它们都拥有各自的内存资源，互不干扰。但是现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：

// 例4.2.4  MutliThreadDemo4.java
class MutliThread implements Runnable
{
    private int ticket = 100;
    public void run()
    {
        while (ticket > 0)
            System.out.println(ticket-- + "  is saled by " + Thread.currentThread().getName());
    }
}
class MutliThreadDemo4
{
    public static void main(String args[])
    {
        MutliThread m = new MutliThread();
        Thread t1 = new Thread(m, "Windows 1");
        Thread t2 = new Thread(m, "Windows 2");
        Thread t3 = new Thread(m, "Windows 3");
        t1.start();
        t2.start();
        t3.start();
    }
}

整个程序和例4.2.2很相似，但是，在主程序中仅创建了一个MutliThread类的对象m，然后使用Thread类的Thread(Runnable target,String name)构造函数创建了三个线程，最后分别调用start()方法启动这些线程。这和例4.2.2有什么区别呢？

前者例4.2.2是先创建三个实现了Runnable接口类的对象，这些对象相当于在内存中分别创建了三个资源，然后为每个资源分别创建了一个线程，此时这三个线程各自拥有一个资源，且彼此独立。而本例中仅创建一个实现了Runnable接口类的对象，因此也就仅创建了一个资源，随后针对这一资源分别创建了三个线程，此时的三个线程彼此之间就有了一定的联系，即要共同处理这同一个资源。尽管具有时间片分配的随机性，但每一时刻只有一个线程在处理该资源，因此可以保证资源的一致性。正是基于这一点，该程序才实现了类似于火车站售票系统的功能。

编译并运行程序，可以看到如图4.2.2的结果：



图中结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。

可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？

实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。


2 / 设置线程的优先级

虽然前面说线程是并发运行的。然而实际情况并非如此。对于多线程的程序，任务角色的不同使得每个线程的重要程度也不尽相同，如多个线程在等待获得CPU时间片，往往希望优先级高的线程优先抢占到CPU并得以执行。此外，多个线程交替执行时，不同优先级决定了级别高的线程将得到CPU的次数多一些且时间长一些，这样，高优先级的线程任务处理的效率明显就会更高一些，从而满足一些特殊的需要。那么，线程的优先级是如何设置的呢？

Java的线程调度器决定了某一线程什么时候该运行，该调度器采用的是一种简单、固定的调度法，即固定优先级调度算法。这种算法是根据处于可运行状态的线程的相对优先级来执行的。

Java中，线程的优先级是介于Thread.MIN_PRIORITY到Thread.MAX_PRIORITY这两个常量之间的某个整数数值（介于1到10之间）。默认情况下，线程的优先级都是5，在Java中用NORM_PRIORITY来表示。其中，MIN_PRIORITY、MAX_PRIORITY和NORM_PRIORITY均是Thread类的静态整型常量。

当利用某一线程又创建了一个新线程对象时，这个新线程将拥有与创建它的线程一样的优先级。例如，主线程的优先级默认情况下是5，那么利用主线程创建的新线程的优先级默认情况下也是5。

线程创建后，线程的优先级可以在需要的时候对其进行修改。修改时需要使用Thread类的setPriority()方法，该方法属于Thread类，其语法格式为：

public final void setPriority(int newPriority

这里，newPriority的值必须在MIN_PRIORITY和MAX_PRIORITY之间，它的值可以是1到10之间的任意数字，也可以是MIN_PRIORITY等这些符号常量。

例如可以使用下面的形式来设置线程的优先级。

Thread.setPriority(Thread.MIN_PRIORITY);

当然，也可以通过调用Thread类的getPriority()方法来得到线程当前的优先级， 该方法也属于Thread类，调用它将返回一个整数数值。其语法格式如下：

public final int getPriority()

由于这两个方法都是final的，因此它们都无法被Thread类的子类所覆盖。在任何时刻，如果有多条线程等待运行，系统将选择优先级最高的可运行线程运行。只有当它停止、自动放弃、或由于某种原因成为非运行状态的线程时，其他优先级的线程才能运行。如果两个线程具有相同的优先级，则它们将被交替地运行。

下面通过一个例子来说明设置线程的优先级是如何影响到线程在程序中所表现的效果的。在这个例子中利用主线程创建了两个用户线程，通过循环来统计两个线程执行的次数。如果它们的优先级相同，则当循环次数很大时，两个线程执行的次数应该非常相近。如果它们的优先级不同，则当循环N次之后，统计的结果会显示优先级大的线程执行的次数比优先级小的线程执行的次数大很多。程序代码如下所示：

// 例4.2.5  MutliThreadDemo5.java
class NewThread extends Thread
{
    private int count;
    private boolean isPass = true; // 定义一个标志，用来终止循环
    NewThread(String name)
    {
        super(name);
    }
    public void run()
    {
        while (isPass) // isPass为假时将中止循环，否则count不断的加1
        {
            count++;
        }
    }
    public int result() // 返回count的值
    {
        return count;
    }
    public void stopThread() // 中止线程
    {
        isPass = false;
    }
}
class MutliThreadDemo5
{
    public static void main(String[] args)
    {
        NewThread t1 = new NewThread("Thread 1");
        NewThread t2 = new NewThread("Thread 2");
        t1.setPriority(Thread.NORM_PRIORITY - 3); // 设置优先级为2
        t2.setPriority(Thread.NORM_PRIORITY + 3); // 设置优先级为8
        t1.start(); // 启动线程t1
        t2.start(); // 启动线程t2
        try
        {
            Thread.sleep(500); // 主线程睡眠500毫秒
        }
        catch (InterruptedException e)
        {
            System.out.println(e.getMessage());
        }
        System.out.println("Thread 1：Priority is " + t1.getPriority() + " Result of Count is: " + t1.result());
        System.out.println("Thread 2：Priority is " + t2.getPriority() + " Result of Count is: " + t2.result());
        t1.setPriority(Thread.MAX_PRIORITY); // 重新设置t1的优先级为最大
        try
        {
            Thread.sleep(500); // 主线程睡眠500毫秒
        }
        catch (InterruptedException e)
        {
            System.out.println(e.getMessage());
        }
        t1.stopThread();
        t2.stopThread();
        System.out.println("After the priority of Thread 1 is changed: ");
        System.out.println("Thread 1：Priority is " + t1.getPriority() + " Result of Count is: " + t1.result());
        System.out.println("Thread 2：Priority is " + t2.getPriority() + " Result of Count is: " + t2.result());
    }
}

程序执行后显示的结果如图4.2.3所示：



由显示的结果可以看到，开始的时候，Thread1的优先级远远低于Thread2的优先级，因此Thread2执行的次数比Thread1多很多。而重新设置了Thread1的优先级，使之成为最大优先级之后，Thread1执行的次数大大增加，而此时的Thread2由于优先级没有Thread1高，其执行的次数增加量变化反而不大。

并不是在所有系统中运行Java程序时都采用时间片策略调度线程，所以一个线程在空闲时应该主动放弃CPU，以使其他同优先级和低优先级的线程得到执行。如本例中对主线程就使用了sleep()方法。其他方法读者可以参考本节后面的相关问题。

专家说明

本小节中介绍了如何创建多线程的程序，还有如何编写使用多线程的程序访问同一资源的方法，同时指出了在创建多线程程序中使用实现Runnable接口创建多线程程序在其他方面的优势。因此应尽量使用Runnable接口来创建多线程以便于程序功能的扩展。另外，还介绍了对于那些紧迫的任务、需要大量消耗CPU时间的线程，如何设置其优先级来保证任务的实现。虽然不能具体精确地控制线程，但是针对那些仅通过设置或改变线程的优先级就可以改善程序性能的现实问题，利用本小节中对线程优先级的设置方法还是很有效果的。

专家指点

最后，要特别指出的是：Java 虽然支持 10 个优先级，但基层操作系统支持的优   先级可能要少得多，这样就有可能造成一些混乱。因此，只能将优先级作为一种很粗略的工具使用，最后的控制可以通过恰当地使用Thread类的 yield()方法来完成。一般情况下，请不要依靠线程优先级来控制线程的状态。关于yield()方法的说明可以参考相关问题。

相关问题

在协作式模型中，是否能保证线程正常放弃处理器，不掠夺其他线程的执行时间，则完全取决于程序员。可以通过调用Thread类的yield()方法，使之能够将当前的线程从处理器中移出并重新放回到准备就绪队列中。另一个途径则是调用 sleep()方法，使线程在 sleep()方法指定的时间间隔内进入睡眠状态，从而放弃处理器。

sleep()方法的使用前面已经介绍过，在此不再赘述。下面简单的介绍一下yield()方法，它是Thread类的静态成员，语法格式如下：

public static void yield()

此方法的功能是可以引起当前正在执行的线程对象临时性的暂停执行重新放回到准备就绪队列中（jvm唤醒后，继续执行yield后面的代码），而使其他线程得到执行(必须是同优先级的线程)。例如，当线程需要放弃某个稀有的资源（如数据库连接或网络端口）时，它可以通过调用yield()方法来临时降低自己的优先级，以便程序中其他低优先级的线程能够运行，并得到这个稀有资源。

将这个方法随意放在代码的某个地方，并不能够保证线程正常工作。例如，如果线程正拥有一个锁（因为它在一个同步方法或代码块中，后面的小节中会讲到有关同步的问题，现在读者对它有一个了解即可），则当它调用 yield() 时由于无法释放这个锁，就意味着即使这个线程已经被挂起，等待这个锁释放的其他线程依然不能继续运行。为了缓解这个问题，最好不在同步方法中调用 yield()方法，否则将那些需要同步的代码包在一个同步块中，里面不含有非同步的方法，并且在这些同步代码块之外才调用 yield()，这样也可以解决这个问题。