前面一节了解了多线程的概念。本节主要介绍如何使用Thread类来创建和启动线程。
在讲解之前，先考虑一个编程任务。假设有一个同学通讯录，通讯录长度为1000，用于记录同学的姓名、电话、地址信息，用户可以并发检索该通讯录，输入通讯录中的姓名，程序从通讯录中查找该姓名，如果存在则输出与该姓名相关的电话、地址信息。任务要求简单模拟1000个用户的并发访问，检索功能分别采用单线程和多线程实现，比较在1000个用户的并发访问下，单线程和多线程的检索效率。
1、线程的创建和启动
Java提供了两种创建线程的方式。
一种方式是定义实现Java.lang.Runnable接口的类。Runnable接口中只有一个run()方法，用来定义线程运行体。代码如下：
package com.milihua.threaddemo;
public class MyRunner implements Runnable {
@Override
public void run() {
// 在线程中执行的代码
for( int i = 0; i<100; i++ ) {
System.out.println("MyRunner:" + i);
}
}
}定义好MyRunner类后，需要把MyRunner类的实例作为参数传入到Thread的构造方法中，来创建一个新线程。代码如下：
package com.milihua.threaddemo;
public class ThreadRunDemo {
public static void main(String[] args) {
Thread thread = new Thread(new MyRunner());
thread.start();
}
}
在ThreadRunDemo类的main方法中，实例化Thread对象，并将MyRunner类的实例作为参数传入进去，然后调用Thread对象的start方法启动线程。线程输出结果如下图所示：
图 15-3 MyRunner线程输出结果
另外一种方式是将类定义为Thread类的子类，并重写Thread类的run()方法，代码如下：
package com.milihua.threaddemo;
public class MyThread extends Thread{
//重写Thread的run方法
public void run()
{
// 在线程中执行的代码
for( int i = 0; i<100; i++ ) {
System.out.println("MyThread:" + i);
}
}
}定义好Thread类的子类后，创建一个线程，只需要创建Thread子类的一个实例即可。代码如下：
package com.milihua.threaddemo;
public class ThreadDemo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread thread = new MyThread();
thread.start();
}
}在ThreadDemo2类的main方法中，只需实例化Thread对象即可，然后调用Thread对象的start方法启动线程。
注意：在两种创建线程的方式中，建议使用第一种方式。因为采用实现接口的方式可以避免由于Java的单一继承带来的局限，有利于代码的健壮性。
2、用单线程完成同学通讯录检索任务
（1）首先建立一个同学通讯录类，代码如下：
package com.milihua.threaddemo;
public class PhoneBook {
String name;
String phone;
String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}（2）初始化通讯录数据，用ArrayList集合类存储1000个PhoneBook对象，代码如下：
public void InitPhoneBook(ArrayList<PhoneBook> inArray)
{
for( int i = 0;i < 1000; i++ )
{
PhoneBook temp = new PhoneBook();
temp.setName("同学" + String.valueOf(i));
temp.setPhone("电话" + String.valueOf(i));
temp.setAddress("地址" + String.valueOf(i));
inArray.add(temp);
}
}（3）用for循环模拟1000个并发客户检索通讯录，并输出通讯录信息，记录检索全部完成时间，代码如下：
package com.milihua.threaddemo;
import java.util.ArrayList;
import java.util.Iterator;
public class PhoneBookSearch {
public static void main(String[] args) {
ArrayList<PhoneBook> array = new ArrayList<PhoneBook>();
PhoneBookSearch phoneBook = new PhoneBookSearch();
phoneBook.InitPhoneBook(array);
long start = System.currentTimeMillis();
for(int i = 0; i < 1000; i++ )
{
phoneBook.searchPhoenBook("同学" + String.valueOf(i),array);
}
long end = System.currentTimeMillis();
long total = end - start;
System.out.println("byCommonFor------->" + total+" ms");
}
public void searchPhoenBook(String inName,ArrayList<PhoneBook> array)
{
Iterator iterator = array.iterator();
int num = 1;
while (iterator.hasNext()) {
PhoneBook temp = (PhoneBook) iterator.next();
if( temp.getName().equals(inName) )
{
System.out.println("姓名：" + temp.getName() + "/电话：" + temp.getPhone() + "/地址:" + temp.getAddress());
return;
}
}
}
public void InitPhoneBook(ArrayList<PhoneBook> inArray)
{
for( int i = 0;i < 1000; i++ )
{
PhoneBook temp = new PhoneBook();
temp.setName("同学" + String.valueOf(i));
temp.setPhone("电话" + String.valueOf(i));
temp.setAddress("地址" + String.valueOf(i));
inArray.add(temp);
}
}
}程序用for循环模拟1000个并发客户检索通讯录，在模拟检索任务开始之前调用System的currentTimeMillis方法获取系统当前时间，模拟检索任务执行结束后，再获取任务执行完成后的时间，然后计算两个时间的差值，该差值就是检索任务运行的时间。程序输出结果如下图所示：
图 15-4 单线程完成同学通讯录检索任输出结果
从上图可以看出，检索结果按顺序输出，耗时46ms。
3、用多线程完成同学通讯录检索任务
（1）改造searchPhoenBook方法为线程
上面代码PhoneBookSearch 类searchPhoenBook方法完成通讯录的检索及信息输出。下面的代码把该方法改造为线程，这样就可以实现当多用户检索通讯录时，程序针对每个用户的检索请求，都会启动一个线程去执行检索任务，由顺序执行改为并发执行。改造代码如下：
package com.milihua.threaddemo;
import java.util.ArrayList;
import java.util.Iterator;
public class SearchPhone implements Runnable {
ArrayList<PhoneBook> array;
String name;
public SearchPhone(String inName,ArrayList<PhoneBook> inArray)
{
array = inArray;
name = inName;
}
@Override
public void run() {
// TODO Auto-generated method stub
Iterator<PhoneBook> iterator = array.iterator();
while (iterator.hasNext()) {
PhoneBook temp = (PhoneBook) iterator.next();
if( temp.getName().equals(name) )
{
System.out.println("姓名：" + temp.getName() + "/电话：" + temp.getPhone() + "/地址:" + temp.getAddress());
return;
}
}
}
}代码定义一个SearchPhone，该类实现Runnable接口，并重写Runnable接口的run()方法，在run方法中，完成通讯录的检索及输出功能。
（2）改造PhoneBookSearch类的main方法
在PhoneBookSearch类的main方法中，不再调用searchPhoenBook方法，而是实例化Thread对象，并将SearchPhone类的实例作为参数传入进去，然后调用Thread对象的start方法启动线程，代码如下：
public static void main(String[] args) {
ArrayList<PhoneBook> array = new ArrayList<PhoneBook>();
PhoneBookSearch phoneBook = new PhoneBookSearch();
phoneBook.InitPhoneBook(array);
long start = System.currentTimeMillis();
for(int i = 0; i < 1000; i++ )
{
//phoneBook.searchPhoenBook("同学" + String.valueOf(i),array);
SearchPhone search = new SearchPhone("同学" + String.valueOf(i),array);
Thread thread = new Thread(search);
thread.start();
}
long end = System.currentTimeMillis();
long total = end - start;
System.out.println("byCommonFor------->" + total+" ms");
}程序输出结果如下图所示：
图 15-5 用多线程完成同学通讯录检索任务输出结果
从输出结果看，检索结果并没有按照顺序输出，整个检索耗时152ms。用多线程技术实现通讯录的并发检索，并没有提高检索效率，反而不如单线程的运行速度快。主要原因是系统每启动一个线程，都要耗费一定的系统资源，导致运行效率降低，多线程在这个例子程序中，并没有体现出多线程的性能优势。
我们换个场景，假如把通讯录的检索放到服务器端，1000个用户在同一时间并发检索通讯录，如果服务端是单线程服务，虽然1000个用户是并发访问，但要在服务器端随机排队等候服务器响应，如果1个用户的响应时间为1秒，那么依次类推，最后1个用户的响应时间为1000秒。如果是多线程服务，平均每个用户的响应时间为2到3秒左右，显然能够满足大多数用户的响应需求。在这个场景下，多线程就体现出了性能优势。
■ 知识点拨
在正常情况下，让程序来完成多个任务，只使用单个线程来完成比用多个线程完成所用的时间会更短。因为JVM在调度管理每个线程上肯定要花费一定资源和时间的。那么，在什么场景下使用多线程呢？一是对用户响应要求比较高，又允许用户并发访问的场景；二是程序存在耗费时间的计算，整个系统都会等待这个操作，为了提高程序的响应，将耗费时间的计算通过线程来完成。