创建线程的三种方式

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）、接口还解决了数据共享的问题。