创建线程一般有如下几个方式：
1. 通过继承Thread类来创建一个线程：
/**
* 步骤1：定义一个继承Thread类的子类
* 步骤2：构造子类的一个对象
* 步骤3：启动线程：
* */
public class ThreadTest{
public static void main(String[] args) {
//构造子类对象
SubThread subThread = new SubThread();
//启动线程
subThread.start();
}
}
//定义继承Thread的子类
class SubThread extends Thread{
public void run(){
System.out.println("Thread test.......");
}
}
2. 通过实现Runnable接口来创建一个线程（静态代理模式）
/**
* 静态代理模式的步骤
* 步骤一： 创建真实角色
* 步骤二： 创建代理角色，持有真实角色的引用
* 步骤三： 两者实现相同的接口
**/
public class RunnableTest {
public static void main(String[] args) {
//创建一个类对象
Runnable subRunnable = new SubRunnable();
//由Runnable创建一个Thread对象
Thread subThread = new Thread(subRunnable);
//启动线程
subThread.start();
}
} //创建实现Runnable接口的类
class SubRunnable implements Runnable{
@Override
public void run() {
System.out.println("Runnable Test......");
}
}
3、通过实现Callable接口来创建一个线程（可返回值，对外声明异常等）
/*
* 步骤一：创建Callable接口的实现类，并重写call()方法
* 步骤二：借助执行调度服务ExecutorService获取Future对象
* 步骤三： get()方法获取值
* 步骤四： shutdownNow()方法停止服务
*/
public class CallableTest {
public static void main(String[] args) {
//借助执行调度服务ExecutorService获取Future对象
ExecutorService ser = Executors.newFixedThreadPool(2);
Race test1 = new Race("LiLei");
Race test2 = new Race("HanMeimei");
Future<String> res1 = ser.submit(test1);
Future<String> res2 = ser.submit(test2); try {
//get()方法获取值
System.out.println(res1.get());
System.out.println(res2.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//shutdownNow()方法停止服务
ser.shutdownNow();
}
} //创建Callable接口的实现类
class Race implements Callable<String> {
private String name; public Race(String name) {
super();
this.name = name;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Override
public String call() throws Exception {
return "Hello "+ name +"......";
}
}
总结：
1、推荐使用接口，原因如下：
1）避免单继承的局限性；
2）便于共享资源
2、两种实现接口的方式（Runnable和Callable）的区别：
1）Callable的启动方法是call(),Runnable的启动方法是run()
2）Callable的任务执行后可返回值，而Runnable的任务无返回值
3）Callable的call方法可以抛出异常，Runnable的run方法不可以
4）Callable任务可以获取Future对象，这个对象提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。