创建线程的三种方式

1、继承Thread类。MyThread继承Thread类， 重写run（）方法，直接创建MyThread 对象，调用start（）方法，来调用子线程。

Class MyThread extends Thread{
public void run() {
for(int i=0;i<26;i++){
try {
MyThread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("当前数字:"+i);
}
}
}
public class TextMyThread {
public static void main(String[] args) {
MyThread my=new MyThread();
my.start();
for(int i=65;i<91;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println((char)i);

}
}

}

2、实现Runnable接口，MyThread11 实现Runnable 接口，重写run（）方法，先创建MyThread11 对象，再创建Thread对象封装MyThread11 对象，最后Thread对象再调用start()方法，来调用子线程。

public class MyThread11 implements Runnable {
@Override
public void run() {
for(int i=0;i<26;i++){
try {
MyThread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("当前数字:"+i);
}
}
}
public class TextMyThread1 {
public static void main(String[] args) {
MyThread11 myt=new MyThread11();
Thread tmt=new Thread(myt);
tmt.start();
for(int i=65;i<91;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println((char)i);

}
}
}

3、实现Callable接口。MyThread2 实现了Callable接口，重写了 call()方法，该方法可以抛出异常且有返回值，创建MyThread2 对象，用FutureTask对象来包装MyThread2 对象，使用FutureTask对象作为Thread对象参数创建并启动线程。

public class MyThread2 implements Callable<Integer>{
@Override
public Integer call() throws Exception {//相当于run()
int i=0;
for(;i<100;i++){             System.out.println(Thread.currentThread().getName()+i);
}
return i;
}

}
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TextMyThread2 {
public static void main(String[] args) {
MyThread2 my2=new MyThread2();//第(1)步
FutureTask<Integer> fre=new FutureTask<Integer>(my2);//第(2)步
new Thread(fre).start();//第(3)步
try {
System.out.println(fre.get());//调用FutureTask对   象的get()方法来获得MyThread2 线程,执行结束后的返回值
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

4、继承Thread类和实现Runnable接口来创建线程区别：

（1）、Thread是类，Runnable是接口，Thread是类实现了Runnable接口；Java只支持单继承，如果一个类用继承Thread类来创建接口，那么该类就不能再继承其他类；如果一个类用实现Runnable接口来创建线程，那么该类还可以继承其他类，解决了单继承问题。

（2）、接口还解决了数据共享的问题。