Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。线程的创建一般有以下三种：
一、继承Thread类创建线程类
- 定义Thread类的子类，并重写该类的run（）方法，该run（）方法的方法体就代表了线程需要完成的任务，因此经常把run（）方法称为线程执行体。
- 创建Thread子类的实例，即创建了线程对象
- 调用线程对象的start（）方法就可以启动该线程
private static void createdThread1() {
for (int i = 0; i < 30; i++) {
// 通过Thread类的currentThread方法可以得到当前的线程名
System.out.println(Thread.currentThread().getName()+" "+i);
if (i==20) {
// 创建并启动第一个线程
new ThreadTest.FirstThread().start();
// 创建并启动第二个线程
new ThreadTest.FirstThread().start();
}
}
}
// 通过继承Thread类来创建线程类
public static class FirstThread extends Thread {
int i;
// 重写run（）方法，run（）方法的方法体是线程的执行体
@Override
public void run() {
super.run();
// 当线程类继承Thread时，直接使用this通过getName()即可获取到当前的线程名
for (; i <30; i++) {
System.out.println(this.getName()+" "+i);
}
}
}
二、实现Runnable接口创建线程类
- 定义Runnable接口的实现类，并重写该接口的run（）方法，该run（）方法的方法体也称之为线程方法执行体。
- 创建Runnable实现类的实例，并将此实例作为形参传入new Thread（）的构造函数中，就可创建Thread线程对象
public static class SecondThread implements Runnable{
int i;
// 重写run（）方法，run（）方法的方法体是线程的执行体
@Override
public void run() {
for (; i <30; i++) {
//当使用Runnable接口实现线程类时，若要得到当前的线程名称，只能用Thread.currendThread（）方法
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
private static void createdThread2() {
for (int i = 0; i < 30; i++) {
// 通过Thread类的currentThread方法可以得到当前的线程名
System.out.println(Thread.currentThread().getName()+" "+i);
if (i==20) {
//通过new Thread(target,name)方式创建新线程
SecondThread secondThread = new ThreadTest.SecondThread();
new Thread(secondThread, "线程1").start();
new Thread(secondThread, "线程2").start();
}
}
}
三、使用Callable和Future创建线程
- 创建Callable接口的实现类，并重写call（）方法，该方法就是线程方法执行体，且call（）方法有执行返回值，再创建Callab实现类的实例。
- 使用FutureTask类的实例，来包装Callable对象，即把callable的实例以形参的方式传入new FutureTask()的构造函数中
- 使用FutureTask对象作为Thread对象的target创建启动先线程。
- 通过FutureTask实例对象调用get（）方法得到子线程的返回值。
public static class ThirdThreadCallable implements Callable<Integer>{
int i ;
//call（）方法称之为线程方法执行体，且该方法有返回值，可通过FutureTask实例对象调用get（）方法得到子线程的返回值
@Override
public Integer call() throws Exception {
for (; i <30; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}
}
private static void createdThread3() {
//创建Callable对象
ThirdThreadCallable callable = new ThreadTest.ThirdThreadCallable();
//创建FutureTask对象，并把callable以形参的方式传入FutureTask的构造方法内
FutureTask<Integer> futureTask = new FutureTask<>(callable);
for (int i = 0; i < 30; i++) {
// 通过Thread类的currentThread方法可以得到当前的线程名
System.out.println(Thread.currentThread().getName()+" "+i);
if (i==20) {
//创建线程并启动
new Thread(futureTask, "有返回值的线程").start();
}
}
//获取子线程的返回值
try {
System.out.println("子线程的返回值： "+futureTask.get());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
四、创建线程的三种方式对比
使用实现Runnable 、Callable接口的方式创建多线程
优点：
- 线程类只是实现了Runnable接口或Callable接口，同时还可以继承其他类。
- 多个线程可以共享一个target对象，非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码、数据分开，形成清晰的模型，较好的体现了面向对象的思想
缺点：
- 编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread（）方法。
使用继承Thread类的方式创建多线程
优点：
- 编写简单，如果要访问当前线程，无需使用Thread.currentThread（）方法，可以直接使用this的方式获取当前线程
缺点：
- 因为线程类已经继承了Thread类，所以不能再继承其他的父类。