java 开启线程的三种方法（Runnable如何避免单继承局限性）

重写run方法

public class runThread extends Thread{
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println("重写run方法线程开启");
        }
    }
}

实现Runnable接口

public class runnableThread implements Runnable{

    @Override
    public void run() {
        for (int i =0;i<10;i++){
            System.out.println("实现Runnable接口线程开启");
        }

    }
}

public class MultiThreadTest {
    public static void main(String[] args) {
        runThread r = new runThread();
        r.start();

        runnableThread a =new runnableThread();
        new Thread(a).start();
    }
}

callable方法

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class callableThread  {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread thread =new MyThread();
        FutureTask futureTask =new FutureTask(thread);
        new Thread(futureTask,"A").start();

        Integer o = (Integer) futureTask.get();
        System.out.println(o);

    }
}
class MyThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("call");
        return 1024;
    }
}

单继承的意思是，一个子类不能有两个以上父类
因此：想要得到两个类的特性是不能通过继承实现。

而接口出现可以解决这个问题。
因为，一个类可以实现多个接口

如果你想写一个类C，但这个类C已经继承了一个类A，此时，你又想让C实现多线程。用继承Thread类的方式不行了。（因为单继承的局限性）
此时，只能用Runnable接口。Runnable接口就是为了解决这种情境出现的。