Java编程-多线程基础

什么是线程

从概念上来说，线程不难理解。指的是程序代码的独立执行路径（it's an independent path of execution through program code）。当多线程执行的时候，一个线程执行的代码通常与另一个线程执行的代码不同。那么JVM是怎么管理每个线程的执行呢？JVM给每一个线程一个方法调用栈（method-call stack），除了跟踪当前的二进制命令之外，还跟踪局部变量和JVM传过来的参数，以及方法的返回值。
Java通过java.lang.Thread来完成多线程功能，每个Thread对象都对应一个线程执行体。线程执行的内容在Thread的run方法中，由于默认run方法是一个空方法，我们可以通过继承Thread类，重写run方法来实现我们的工作。

Program 1: ThreadDemo.java

//ThreadDemo.java
class ThreadDemo
{
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        mt.start();
        for (int i = 0; i < 50; i++)
        {
            System.out.println("i = " + i + ", i * i = " + i * i);
        }
    }

}

class MyThread extends Thread
{
    @Override
    public void run()
    {
        for (int count = 1, row = 1; row < 20; count++, row++)
        {
            for (int i = 0; i < count; i++)
            {
                System.out.print('*');
            }
            System.out.println();
        }
    }
}

当我们使用java ThreadDemo去执行上述代码时，JVM创建了一个主线程执行main方法，通过执行mt.start()之后，主线程通知JVM去创建另一个线程用来执行MyThread当中的run方法。当start()方法返回之后，主线程继续执行for的代码块，而另一个线程执行run方法。

Thread类

为了能够更熟练地使用Java多线程。我们需要了解构成Thread类的一些方法，他们包括如何开始一个线程，如何为线程命名，如何让线程暂停，如何确定一个线程是否活跃，如果将一个线程连接至另一个线程，如何得到当前上下文活跃线程数量，以及如何做多线程的调试。

创建一个线程

线程有八个构造器，最简单的是

Thread() //创建一个具有默认名字的线程实例
Thread(String name) //创建一个具有指定名字的线程实例

与之对应的还有

Thread(Runnable target)
Thread(Runnable target, String name)

上面两组构造器，不同的只有Runnable参数，Runnable参数确定了那些Thread类之外的提供run函数的对象。最后四个构造器组合了上述构造器，同时添加了ThreadGroup参数。
其中构造器

Thread(ThreadGroup group, Runnable target, String name, long stackSize)

可以让你指定方法调用栈（method-call stack）的深度，这对于一些以递归方式实现的方法来说很有用（可以避免StackOverFlowErrors）。
Thread类和Thread类的子类，它们都不是具体的线程。它们描述了线程的属性，例如线程的名字和线程执行的run方法。在调用一个Thread类的start方法时，JVM会按照Thread类描述的模板去创建一个线程并调用run方法。
在调试阶段，区分一个线程和其他的线程是很有必要的。Java将线程的名字和线程相绑定。线程的名字默认为"Thread"+"-"+"从0开始的整型"，例如"Thread-0"。我们在构造器里面可以传入自定义的字符串作为名字。

线程的Sleep

调用Thread的静态方法sleep(long millis)可以强制一个线程暂停millis毫秒。其他线程可以中断正在休眠的线程，如果发生了，那么正在休眠的线程清醒然后抛出一个InterruptedException。因此sleep方法必须包含在try块或者调用sleep的方法抛出一个异常。
下面使用一个计算pi（圆周率）的程序来说明sleep的作用。

Program 2: CalcPI1.java

//CalcPI1.java
class CalcPI1
{
   public static void main (String [] args)
   {
      MyThread mt = new MyThread ();
      mt.start ();
      try
      {
          Thread.sleep (10); // Sleep for 10 milliseconds
      }
      catch (InterruptedException e)
      {
      }
      System.out.println ("pi = " + mt.pi);
   }
}
class MyThread extends Thread
{
   boolean negative = true;
   double pi; // Initializes to 0.0, by default
   public void run ()
   {
      for (int i = 3; i < 100000; i += 2)
      {
           if (negative)
               pi -= (1.0 / i);
           else
               pi += (1.0 / i);
           negative = !negative;
      }
      pi += 1.0;
      pi *= 4.0;
      System.out.println ("Finished calculating PI");
   }
}

可以注释掉try...catch语句块来看看不调用sleep和调用sleep的差别。可以看出如果注释掉try...catch块后，PI的值打印出来为0，那是因为主线程执行的比计算PI的线程快，所以在PI计算完成之前已经将PI的值打印了出来。因此为了得到正确的PI值，我们要让主线程休眠一会等待另一个线程完成PI的计算。

线程的死活

当程序调用了线程实例的start方法并在调用run方法前会有一段时间（用于线程的初始化）。当线程的run方法返回后并在JVM清理这个线程之前也有一段时间。在run方法调用前的一瞬间到run方法返回后的一瞬间之间的时间，Thread的isAlive方法会返回true，其余时间返回false。

当一个线程的运行依赖于另外一个线程的结果时，isAlive方法就变得很有用了。通过while循环不断调用isAlive方法，直到返回false。这样就可以确保一个线程在另一个线程结束后运行。
下面给出一个修改版本的PI计算代码

Program 3: CalcPI2.java

//CalcPI2.java
class CalcPI2
{
   public static void main (String [] args)
   {
      MyThread mt = new MyThread ();
      mt.start ();
      while (mt.isAlive ())
        try
        {
            Thread.sleep (10); // Sleep for 10 milliseconds
        }
        catch (InterruptedException e)
        {
        }
      System.out.println ("pi = " + mt.pi);
   }
}
class MyThread extends Thread
{
   boolean negative = true;
   double pi; // Initializes to 0.0, by default
   public void run ()
   {
      for (int i = 3; i < 100000; i += 2)
      {
           if (negative)
               pi -= (1.0 / i);
           else
               pi += (1.0 / i);
           negative = !negative;
      }
      pi += 1.0;
      pi *= 4.0;
      System.out.println ("Finished calculating PI");
   }
}

线程的Join

由于线程的sleep方法和isAlive方法都很实用，所以Sun将它们打包成了三个方法：join()、join(long millis)和join(long millis, int nanos)。当一个线程想要等待另一个线程结束时，这个线程可以通过另一个线程的引用来调用join方法。下面为PI计算代码的Join方法实现。注意默认不带参数的join方法是阻塞的，直到线程结束为止，而使用join(long millis)可以设置一个超时时间millis。

Program 4: CalcPI3.java

// CalcPI3.java
class CalcPI3
{
   public static void main (String [] args)
   {
      MyThread mt = new MyThread ();
      mt.start ();
      try
      {
          mt.join ();
      }
      catch (InterruptedException e)
      {
      }
      System.out.println ("pi = " + mt.pi);
   }
}
class MyThread extends Thread
{
   boolean negative = true;
   double pi; // Initializes to 0.0, by default
   public void run ()
   {
      for (int i = 3; i < 100000; i += 2)
      {
           if (negative)
               pi -= (1.0 / i);
           else
               pi += (1.0 / i);
           negative = !negative;
      }
      pi += 1.0;
      pi *= 4.0;
      System.out.println ("Finished calculating PI");
   }
}

统计线程的情况

在某些场景下，我们可能希望知道当前程序里面有多少个活跃的线程。Thread类提供了一对方法用来帮助你完成这些工作：activeCount()和enumerate(Thread[] threads)。但是这些方法只能在当前线程所属线程组的上下文里工作。换句话说，这些方法只能找到与当前线程属于同一个线程组的活跃线程。
静态方法activeCount()返回当前线程组活跃的线程数量。一个程序使用activeCount()的整型返回值线程引用数组的大小。为了获得这些引用，程序必须调用静态的enumerate(Thread[] threads)方法，该方法的整型返回值线程引用数组的数量。

Program 5: ThreadCensus.java

//ThreadCensus.java
public class ThreadCensus
{
   public static void main(String[] args)
   {
       Thread[] threads = new Thread[Thread.activeCount()];
       int n = Thread.enumerate(threads);
       for (int i = 0; i < n; i++)
       {
           System.out.println(threads[i]);
       }
   }
}

上述例子说明了这对方法的使用。输出结果应该为Thread[main, 5, main]。第一个main代表线程的名字，5代表线程的优先级，第二个main代表该线程属于哪个线程组。我们可能会觉得奇怪，为什么在输出没有看到系统的线程。Thread的静态方法enumerate(Thread[] threads)只能询问与当前线程属于同一个线程组的活跃线程。但是在ThreadGroup类里面包含了多个enumerate()方法允许你去捕捉所有线程的引用。ThreadGroup将在之后的章节中提及。
不要依赖activeCount返回的结果：因为在activeCount方法到enumerate方法之间，有可能有线程会终止，这样会导致activeCount返回值不在有效，用这个返回值去遍历线程引用数组时会发生越界的错误。

线程调试

如果你的程序遇到故障，而你发现这个故障可能与一个线程有关，你可以通过Thread.dumpStack()来取得这个线程的详细信息。静态的dumpStack()方法提供了new Exception("Stack trace").printStackTrace()的包裹。

线程的等级

并不是所有线程都是平等的。线程分为两类，一种是用户线程，一种是守护线程。一个用户线程执行用户程序的工作，这些工作必须在应用终止之前完成。而守护线程一般执行内务（例如垃圾回收器（garbage collection））和其他的后台任务，这些后台任务不需要依赖于应用的主要工作，但是应用的主要工作需要这些后台任务。与用户线程不同的是，守护线程不需要在用户线程结束之前完成任务。当一个应用的开始线程（即用户线程）终止时，JVM会检查其他用户线程是否还在运行，如果一些还在，那么JVM会阻止该应用的终止。但如果是守护线程的话，JVM会不管是否有后台线程还在运行终止这个应用。如果想要得到当前线程的引用，可以使用Thread.currentThread()获得。
当你调用线程对象的start()方法时，新创建的线程是用户线程（默认）。如果想要创建一个守护线程，在调用start()方法前，需要调用setDeamon()方法来设置。我们可以使用Thread.isDaemon()来判断一个线程是否为守护线程。

Program 6: UserDaemonThreadDemo.java

//UserDaemonThreadDemo.java
public class UserDaemonThreadDemo
{
    public static void main(String[] args)
    {
        if (args.length == 0)
        {
            new MyThread().start();
        }
        else
        {
            MyThread mt = new MyThread();
            mt.setDaemon(true);
            mt.start();
        }
        try
        {
            Thread.sleep(100);
        }
        catch(InterruptedException e)
        {

        }
    }
}

class MyThread extends Thread
{
    @Override
    public void run()
    {
        System.out.println("Daemon:" + isDaemon());
        while(true);
    }
}

上述程序根据是否传入命令行参数来创建守护线程或用户线程。如果是用户线程，程序会一致运行，我们需要按下Ctrl+C来终止程序，如果是守护线程，守护进程会随着主线程的终止而终止。

使用Runnable创建线程

除了通过扩展Thread类，重写run方法来创建之外，还有别的方式创建线程。我们知道Java中不允许多继承的存在，一个类如果继承自非线程类，那么它就不能继承自线程类。由于继承的限制，我们如何把多线程引入到一个其他类的子类呢，Java提供了使用Runnable来创建线程的方法。使用Runnable实现计算PI的线程。

Program 7: CalcPI4.java

//CalcPI4.java
class CalcPI4
{
   public static void main (String [] args)
   {
      MyThread runnable = new MyThread();
      Thread mt = new Thread(runnable);
      mt.start ();
      try
      {
          Thread.sleep (10); // Sleep for 10 milliseconds
      }
      catch (InterruptedException e)
      {
      }
      System.out.println ("pi = " + runnable.pi);
   }
}
class MyThread implements Runnable
{
   boolean negative = true;
   double pi; // Initializes to 0.0, by default
   public void run ()
   {
      for (int i = 3; i < 100000; i += 2)
      {
           if (negative)
               pi -= (1.0 / i);
           else
               pi += (1.0 / i);
           negative = !negative;
      }
      pi += 1.0;
      pi *= 4.0;
      System.out.println ("Finished calculating PI");
   }
}