什么是线程
从概念上来说，线程不难理解。指的是程序代码的独立执行路径（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");
}
}
