一、继承Thread类创建线程类
（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。
[java] view plain copy
1. package com.thread;
2.
3. public class FirstThreadTest extends Thread{
4. int i = 0;
5. //重写run方法，run方法的方法体就是现场执行体
6. public void run()
7. {
8. for(;i<100;i++){
9. System.out.println(getName()+" "+i);
10.
11. }
12. }
13. public static void main(String[] args)
14. {
15. for(int i = 0;i< 100;i++)
16. {
17. System.out.println(Thread.currentThread().getName()+" : "+i);
18. if(i==20)
19. {
20. new FirstThreadTest().start();
21. new FirstThreadTest().start();
22. }
23. }
24. }
25.
26. }
上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
二、通过Runnable接口创建线程类
（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
（3）调用线程对象的start()方法来启动该线程。
三：Java多线程之Callable和Future接口的实现
Callable接口定义了一个call（）方法可以作为线程的执行体，call方法比run方法更强大：
A、call方法可以有返回值
（FutureTask：它实现了Futrue和Runnable接口，可以作为Thread的入参启动线程）
B、call方法可以申明抛出异常
C、Callable接口是JDK5后新增的接口，而且不是Runnable的子接口，所以Callable对象不能直接作为Thread的target。而且call方法还有一个返回值，
JDK1.5提供了Future接口来代表Callable接口里的call方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现Future接口，也实现了Runnable接口，可以作为Thread的target入参。
Future接口里定义了如下几个公共方法控制他关联的Callable任务：*******(核心)*******
A、boolean cancel(Boolean mayInterruptlfRunning):试图取消该Future里关联的Callable任务
B、V get()：返回Callable任务里的call方法的返回值，调用该方法将导致线程阻塞，必须等到子线程结束才得到返回值
C、V get(long timeout, TimeUnit unit)：返回Callable任务里的call方法的返回值，该方法让程序最多阻塞timeout和unit指定的时间。
如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException。
D、boolean isCancelled()：如果在Callable任务正常完成前被取消，则返回true。
E、boolean isDone()：如果Callable任务已经完成，则返回true
创建、并启动有返回值的线程的实例代码如下：
一、创建Callable接口的实现类，并实现call方法，该call方法的返回值，并作为线程的执行体。
二、创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值
三、使用FutureTask对象作为Thread对象的target创建、并启动新线程
四、调用FutureTask对象的方法来获得子线程执行结束后的返回值
===================================================================
package com.del;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class TestCallable {
public static void main(String[] args) {
//1.创建Callable实现类的实例
ThreadDemo td = new ThreadDemo();
//2.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
FutureTask<Integer> result = new FutureTask<Integer>(td);
//3.FutureTask实现了Runnable, Future<V>,接口，Thread也实现了Runnable接口，所以 FutureTask可以入参
new Thread(result).start();
//4.接收线程运算后的结果
try {
//调用get()方法将导致线程阻塞，必须等到子线程结束才得到返回值
Integer sum = result.get();
System.out.println("call方法的返回值："+sum);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ThreadDemo implements Callable<Integer> {
/**
* 重写call()方法
*/
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100000; i++) {
sum += i;
}
return sum;
}
}
===================================================================
说明：
1. Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Runnable接口没有strar()方法，只能由Thread来启动！Thread类实际上也是实现了Runnable接口的类。
2. 在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
3. 实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
4. 在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。
总结：创建线程的三种方式的对比
1：使用继承Thread类的方式创建多线程
优势：
编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
劣势是：
线程类已经继承了Thread类，所以不能再继承其他父类。
:2：采用实现Runnable、Callable接口的方式创见多线程
优势：
线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
劣势：
编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。:
3：Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结：
多实现Runnable接口比单继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
4）： 线程池只能放入实现Runable或callable类线程，不能直接放入继承
Thread的类
4：Callable和Runnable的区别
1. Callable和Runnable有几点不同：
2. * （1）Callable规定的方法是call()，而Runnable规定的方法是run().
3. * （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
4. * （3）call()方法可抛出异常，而run()方法是不能抛出异常的。
5. * （4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。
6. * 它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
7. * 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。