Java中创建线程的三种方式

1.继承Thread类并重写run方法

/**
 * 继承Thread类并重写run方法
 */
public class ThreadTest{
    public static class MyThread extends Thread {
        @Override
        /**
         * 重写run方法
         */
        public void run() {
            System.out.println("I am a child thread");
        }
    }
    public static void main(String[] args) {
        //创建线程
        MyThread thread=new MyThread();
        //启动线程
        thread.start();
    }
}

运行结果为：

我们在main函数中创建了一个MyThread的实例（该类继承了Thread），然后调用start方法启动了线程，我们需要注意的是，当我们创建完线程对象后，该线程并没有被启动执行，直到调用了start方法后才真正启动了线程。在调用了start方法后线程并没有马上执行，而是处于就绪状态

继承Thread的优缺点

• 优点：使用继承方式的好处是，在run()方法内获取当前线程直接使用this就可以了，无需使用Thread.currentThread()方法
• 缺点：Java由于不支持多继承，如果继承了Thread类，那么就不能再继承其他类

2.实现Runnable接口的run方法

/**
 * 实现Runnable接口的run方法
 */
public  class RunnableTask implements Runnable {
    /**
     * 实现run方法
     */
    @Override
    public void run() {
        System.out.println("I am a child thread");
    }

    public static void main(String[] args) {
        //创建线程
        RunnableTask task=new RunnableTask();
        new Thread(task).start();
        new Thread(task).start();
    }
}

实现Runnable接口的优缺点

• 优点：实现了Runnable的类可以继承其他类
• 缺点：和继承了Thread的方法一样，run方法都没有返回值

3.使用FutureTask方式

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

public class CallerTask implements Callable<String> {
    @Override
    public String call() throws Exception{
        return "hello";
    }

    public static void main(String[] args) throws InterruptedException{

        //创建异步任务
        FutureTask<String> futureTask=new FutureTask<>(new CallerTask());

        //启动线程
        new Thread(futureTask).start();
        try{
            //等待任务执行完毕，并返回结果
            String result=futureTask.get();
            System.out.println(result);
        }catch (ExecutionException e){
            e.printStackTrace();
        }
    }
}