一文看完最详细的线程创建方式

我们都知道新建线程有三种方式，分别是：

1. 继承Thread类；

2. 实现runnable接口；

3. 实现callable接口；

由于各种方式的写法多样，有时候会造成初学者的困扰，通过本文你可以完整学习到创建线程的各种方式。

这是关于lambda表达式的基础知识，可以先不看，请往下阅读，如有问题回过头来再看。http://www.codebaoku.com/it-java/it-java-224741.html

继承Thread

1、最初级的写法

public class ThreadTest extends Thread{
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
    @Override
    public void run() {
        System.out.println("这是初级方式");
    }
}

2、匿名内部类的写法

public class ThreadTest{
    public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println("这是匿名内部类的方式");
            }
        };
        thread.start();
    }
}

实现runnable接口

1、常规写法

public class RunnableTest implements Runnable{
    @Override
    public void run() {
        System.out.println("这是常规写法");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableTest());
        thread.start();
    }
}

2、匿名内部类的写法

public class RunnableTest{
    

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是匿名内部类的方式");
            }
        });
        thread.start();
    }
}

3、lambda表达式的写法

public class ThreadTest{
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            System.out.println("lambda表达式的写法");
        });
        thread.start();
    }
}

实现callable接口

上面两种方式新建线程是没有返回值的，如果对线程执行后有返回值需求的话，就用这种方式，也即线程池的方式。

1、常规方式

常规方式类似于上面的runnable的写法。

package concurrent;

import java.util.concurrent.*;

public class ImplCallableTest implements Callable{

    @Override
    public Object call() throws Exception {
        return "这个常规的实现方式";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future submit = executorService.submit(new ImplCallableTest());
        Object o = submit.get();
        System.out.println((String)o);
    }
}

2、匿名内部类

package concurrent;

import java.util.concurrent.*;

public class PoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<Object> future = executorService.submit(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                System.out.println("通过callable接口实现");
                return "通过callable接口实现";
            }
        });
        try {
            String o = (String)future.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

3、lambda表达式的写法

package concurrent;

import java.util.concurrent.*;

public class PoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<String> future = (Future<String>) executorService.submit(()->{
            return "这是箭头函数的形式";
        });
        try {
            String o = (String)future.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}