第一种：继承Thread

首先继承Thread方法，重写Thread的run()方法
在main()方法里创建一个MyThread对象，调用该对象的start()方法，start()方法会通过对系统底层的一系列操作，创建出一个相应的线程，与当前线程并发执行。如果直接调用run()方法，程序将执行完run()方法后才会执行main()方法中后面的代码,这样就是单线程执行而不是多线程并发执行了。

public class MyThread extends Thread {
    @Override
    public void run() {
        doSomething();
    }
    private void doSomething(){
        System.out.println("Just do it!");
    }
}

public class Main{
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

第二种：实现Runnable接口

使用Runnable接口与继承Thread类的用法相似

不同的是，实现Runnable接口的类中没有start()方法，所以要用Thread构造个方法开启线程

public class RunnableThread implements Runnable {
    @Override
    public void run() {
        doSomething();
    }
    private void doSomething(){
        System.out.println("Just do it!");
    }
}

public class Main{
    public static void main(String[] args) {
        RunnableThread runnableThread = new RunnableThread();
        Thread thread = new Thread(runnableThread);
        thread.start();
    }
}

第三种：是实现Callable接口和Future创建线程

首先创建Callable接口的实现类CallableThread，实现call()方法，并且有返回值。Callable接口是一个带泛型的接口，泛型的类型就是线程返回值的类型。实现Callable接口中的call()方法，方法的返回类型与泛型的类型相同。

Callable不能直接获取返回值，需要用FutureTask在外部封装一下再获取返回值

public class CallableThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        doSomething();
        return "over";
    }

    private void doSomething(){
        System.out.println("Just do it!");
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new CallableThread();//callable不能直接获取返回值
        FutureTask<String> futureTask = new FutureTask<String>(callable);//需要futureTask封装一下，获取返回值
        Thread thread = new Thread(futureTask);
        thread.start();
        doSomething();
        System.out.println(futureTask.get());
    }

    private static void doSomething() {
        System.out.println("main");
    }
}

第四种使用线程池创建线程

文章链接