Java 学习之路 之 线程的创建和启动（七十三）

Java 使用 Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流（一段顺序执行的代码）。Java 使用线程执行体来代表这段程序流。

1，继承 Thread 类创建线程类

通过继承 Thread 类来创建并启动多线程的步骤如下。

（1）定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程需要完成的任务。因此把 run() 方法称为线程执行体。

（2）创建 Thread 子类的实例，即创建了线程对象。

（3）调用线程对象的 start() 方法来启动该线程。

下面程序示范了通过继承 Thread 类来创建并启动多线程。

// 通过继承Thread类来创建线程类
public class FirstThread extends Thread
{
	private int i ;
	// 重写run方法，run方法的方法体就是线程执行体
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			// 当线程类继承Thread类时，直接使用this即可获取当前线程
			// Thread对象的getName()返回当前该线程的名字
			// 因此可以直接调用getName()方法返回当前线程的名
			System.out.println(getName() +  " " + i);
		}
	}
	public static void main(String[] args) 
	{
		for (int i = 0; i < 100;  i++)
		{
			// 调用Thread的currentThread方法获取当前线程
			System.out.println(Thread.currentThread().getName()
				+  " " + i);
			if (i == 20)
			{
				// 创建、并启动第一条线程
				new FirstThread().start();
				// 创建、并启动第二条线程
				new FirstThread().start();
			}
		}
	}
}

上面程序中的 FirstThread 类继承了 Thread 类，并实现了 run() 方法，如程序中第 6至15 行代码所示，该 run() 方法里的代码执行流就是该线程所需要完成的任务。程序的主方法中也包含了一个循环，当循环变量 i 等于 20 时创建并启动两个新线程。运行上面程序，会看到如图 16.1 所示的界面。

虽然上面程序只显式地创建并启动了 2 个线程，但实际上程序有 3 个线程，即程序显式创建的 2 个子线程和主线程。前面已经提到，当 Java 程序开始运行后，程序至少会创建一个主线程，主线程的线程执行体不是由 run() 方法确定的，而是由 main() 方法确定的—— main() 方法的方法体代表主线程的线程执行体。

进行多线程编程时不要忘记了 Java 程序运行时默认的主线程，main() 方法的方法体是主线程的线程执行体。

除此之外，上面程序还用到了线程的如下两个方法。

Thread.currentThread()： currentThread() 是 Thread 类的静态方法，该方法总是返回当前正在执行的线程对象。

getName()：该方法是 Thread 类的实例方法，该方法返回调用该方法的线程名字。

程序可以通过 setName(String name) 方法为线程设置名字，也可以通过 getName() 方法法返回指定线程的名字，在默认情况下，主线程的名字为 main，用户启动的多个线程的名称依次为 Thread-0、Thread-1、Thread-2、...、Thread-n 等。

从图 16.1 中的灰色覆盖区域可以看出，Thread-0 和 Thread-1 两个线程输出的 i 变量不连续——注意：i 变量是 FirstThread 的实例属性，而不是局部变量，但因为程序每次创建线程对象时都需要创建一个 FirstThread 对象，所以 Thread-0 和 Thread-1 不能共享该实例属性。

使用继承 Thread 类的方法来创建线程类时，多个线程之间无法共享线程类的实例变量。

2，实现 Runnable 接口创建线程类

实现 Runnable 接口来创建并启动多线程的步骤如下。

（1）定义 Runnable 接口的实现类，并重写该接口的 run() 方法，该 run() 方法的方法体同样是该线程的线程执行体。

（2）创建 Runnable 实现类的实例，并以此实例作为 Thread 的 target 来创建 Thread 对象，该 Thread 对象才是真正的线程对象。代码如下所示：

// 创建 Runnable 实现类的对象
SecondThread st = new SecondThread();
// 以 Runnable 实现类的对象作为 Thread 的 target 来创建 Thread 对象，即线程对象
new Thread(st);

也可以在创建 Thread 对象时为该 Thread 对象指定个名字，代码如下所示：

// 创建 Thread 对象时指定 target 和新线程的名字
new Thread(st , "新线程 1");

Runnable 对象仅仅作为 Thread 对象的 target，Runnable 实现类里包含的 run() 作为线程执行体。而实际的线程对象依然是 Thread 实例，只是该 Thread 线程负责执行器 target 的 run() 方法。

（3）调用线程对象的 start() 方法来启动该线程。

下面程序示范了通过实现 Runnable 接口来创建并启动多线程。

// 通过实现Runnable接口来创建线程类
public class SecondThread implements Runnable
{
	private int i ;
	// run方法同样是线程执行体
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			// 当线程类实现Runnable接口时，
			// 如果想获取当前线程，只能用Thread.currentThread()方法。
			System.out.println(Thread.currentThread().getName()
				+ "  " + i);
		}
	}
		
	public static void main(String[] args) 
	{
		for (int i = 0; i < 100;  i++)
		{
			System.out.println(Thread.currentThread().getName()
				+ "  " + i);
			if (i == 20)
			{
				SecondThread st = new SecondThread();     // ①
				// 通过new Thread(target , name)方法创建新线程
				new Thread(st , "新线程1").start();
				new Thread(st , "新线程2").start();
			}
		}
	}
}

上面程序中第 6至15 行代码实现了 run() 方法，也就是定义了该线程的线程执行体。对比 FirstThread 中的 run() 方法体和 SecondThread 中的 run() 方法体不难发现，通过继承 Thread 类来获得当前线程对象比较简单，直接使用 this 就可以了；但通过实现 Runnable 接口来获得当前线程对象，则必须使用 Thread.cunentThread() 方法。

除此之外，上面程序中创建了两个 Thread 对象，并调用 start() 方法来启动这两个线程。在 FirstThread 和 SecondThread 中创建线程对象的方式有所区别：前者直接创建的 Thread 子类即可代表线程对象；后者创建的 Runnable 对象只能作为线程对象的 target。

运行上面程序，会看到如图 16.2 所示的界面。

从图 16.2 中的两个灰色覆盖区域可以看出，两个子线程的 i 变量是连续的，也就是采用 Runnable 接口的方式创建的多个线程可以共享线程类的实例属性。这是因为在这种方式下，程序所创建的 Runnable 对象只是线程的 target，而多个线程可以共享同一个 target，所以多个线程可以共享同一个线程类（实际上应该是线程的 target 类）的实倒属性。

3，使用 Callable 和 Future 创建线程

前面已经指出，通过实现 Runnable 接口创建多线程时，Thread 类的作用就是把 run() 方法包装成线程执行体。那么是否可以直接把任意方法都包装成线程执行体呢？Java 目前不行！但 Java 的模仿者 C# 可以（C# 可以把任意方法包装成线程执行体，包括有返回值的方法）。

也许受此启发，从 Java 5 开始，Java 提供了 Callable 接口，该接口怎么看都像是 Runnable 接口的增强版，Callable 接口提供了一个 call() 方法可以作为线程执行体，但 call() 方法比 run() 方法功能更强大。

call() 方法可以有返回值。

call() 方法可以声明抛出异常。

因此我们完全可以提供一个 Callable 对象作为 Thread 的 target，而该线程的线程执行体就是该 Callable 对象的 call() 方法。问题是：Callable 接口是 Java 5 新增的接口，而且它不是 Runnable 接口的子 接口，所以 Callable 对象不能直接作为 Thread 的 target。而且 call() 方法还有一个返回值——call() 方法并不是直接调用，它是作为线程执行体被调用的。那么如何获取 call() 方法的返回值呢？

Java 5 提供了 Future 接口来代表 Callable 接口里 call() 方法的返回值，并为 Future 接口提供了一个 FutureTask 实现类，该实现类实现了 Future 接口，并实现了 Runnable 接口——可以作为 Thread 类的 target。

在 Future 接口里定义了如下几个公共方法来控制它关联的 Callable 任务。

boolcan cancel(boolean maylnterruptlfRunning)：试图取消该 Future 里关联的 Callable 任务。

V get()：返回 Callable 任务里 call() 方法的返回值。调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值。

V get(long timeout, TimeUnit unit)：返回 Callable 任务里 call() 方法的返回值。该方法让程序最多阻塞 timeout 和 unit 指定的对间，如果经过指定时间后 Callable 任务依然没有返回值，将会抛出 TimeoutExccption 异常。

boolean isCancelled()：如果在 Callable 任务正常完成前被取消，则返回 true。

boolean isDone()：如果 Callable 任务已完成，则返回 true。

Callable 接口有泛型限制，Callable 接口里的泛型形参类型与 call() 方法返回值类型相同。

创建并启动有返回值的线程的步骤如下。

（1）创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，且该 call() 方法有返回值。

（2）创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

（3）使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

（4）调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

下面程序通过实现 Callable 接口来实现线程类，并启动该线程。

// 实现Callable接口来实现线程
public class ThirdThread implements Callable<Integer>
{
	// 实现call方法，作为线程执行体
	public Integer call()
	{
		int i = 0;
		for ( ; i < 100 ; i++ )
		{
			System.out.println(Thread.currentThread().getName()
				+ " 的循环变量i的值：" + i);
		}
		// call()方法可以有返回值
		return i;
	}

	public static void main(String[] args) 
	{
		// 创建Callable对象
		ThirdThread rt = new ThirdThread();
		// 使用FutureTask来包装Callable对象
		FutureTask<Integer> task = new FutureTask<Integer>(rt);
		for (int i = 0 ; i < 100 ; i++)
		{
			System.out.println(Thread.currentThread().getName()
				+ " 的循环变量i的值：" + i);
			if (i == 20)
			{
				// 实质还是以Callable对象来创建、并启动线程
				new Thread(task , "有返回值的线程").start();
			}
		}
		try
		{
			// 获取线程返回值
			System.out.println("子线程的返回值：" + task.get());
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}
}

上面程序中创建 Callable 实现类与创建 Runnable 实现类并没有人大的差别，只是 Callable 的 call() 方法允许声明抛出异常，而且允许带返回值。

上面程序第 5至15,20,21 行是以 Callable 对象来启动线程的关键代码。程序先创建一个 Callable 实现类的实例，然后将该实例包装成一个 FutureTask 对象。主线程中当循环变量 i 等于 20 时，程序启动以 FutureTask 对象为 target 的线程。程序最后调用 FutureTask 对象的 get() 方法来返回 call() 方法的返回值——该方法将导致主线程被阻塞，直到 call() 方法结束并返回为止。

运行上面程序，将看到主线程和 call() 方法所代表的线程交替执行的情形，程序最后还会输出 call() 方法的返回值。

4，创建线程的三种方式对比

通过继承 Thread 类或实现 Runnable、Callable 接口都可以实现多线程，不过实现 Runnable 接口与实现 Callable 接口的方式基本相同，只是 Callable 接口里定义的方法有返回值，可以声明抛出异常而已。因此可以将实现 Runnable 接口和实现 Callable 接口归为一种方式。这种方式写继承 Thread 方式之间的主要差别如下。

采用实现 Runnable、Callable 接口的方式创建多线程——

线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个 target 对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将 CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：编程稍稍复杂，如果需要访问当前线程，则必须使用 Thread.currentThread() 方法。

采用继承 Thread 类的方式创建多线程——

劣势是：因为线程类已经继承了 Thread 类，所以不能再继承其他父类。

优势是：编写简单，如果需要访问当前线程，则无须使用 Threard.currentThread() 方法，直接使用 this 即可获得当前线程。

鉴于上面分析，因此一般推荐采用实现 Runnable 接口、Callable 接口的方式来创建多线程。