一、继承Thread方法

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "输出内容");
        }
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread1.start();
        thread2.start();
    }
}

输出结果：

线程1输出内容
线程2输出内容
线程1输出内容
线程2输出内容
线程2输出内容
线程2输出内容
线程2输出内容
线程2输出内容
线程2输出内容
线程1输出内容
线程2输出内容
线程1输出内容
线程1输出内容
线程1输出内容
线程1输出内容
线程2输出内容
线程2输出内容
线程1输出内容
线程1输出内容
线程1输出内容

         最简单的实现多线程的方法，但拓展性差，Java中只能继承一个父类，也就意味着不能继承其他类了。

二、实现Runable接口

public class MyThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "输出内容");
        }
    }
    public static void main(String[] args) {
        MyThread1 run = new MyThread1();
        Thread thread1 = new Thread(run);
        Thread thread2 = new Thread(run);
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread1.start();
        thread2.start();
    }
}

         拓展性好，可以继承其他类或接口的方法，但是不能使用Thread类中的方法了。
这里获取线程名称时，使用了Thread.currentThread()静态方法来获取运行线程。

 三、实现Callable接口

public class MyThread2 implements Callable<String> {
    @Override
    public String call() {
        return Thread.currentThread().getName() + "输出结果";
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread2 myThread2 = new MyThread2();
        FutureTask<String> future = new FutureTask(myThread2);
        Thread thread1 = new Thread(future);
        thread1.setName("线程1");
        thread1.start();
        String result = future.get();
        System.out.println(result);
    }
}

前两种方法都不能将线程运行的结果返回，实现Callable接口就可以实现线程运行结果的返回了。

通过Future来管理线程返回的内容。
其中FutureTask实现类，实现了RunnableFuture接口，RunnableFuture又继承了Runnable和 Future两个接口。