线程创建的5种方式（面试）

线程创建的5种方式（面试）

线程创建有几种方式这个可以说是经典面试题了，我之前看到一个有趣的说法：如果你要说有 1种、2种、3种、4种 其实也是可以的。重要的是，你要能说出你的依据，讲出它们各自的不同点和共同点。讲得头头是道，让面试官对你频频点头。

接下来我来说说创建线程的5种方式：

1.继承Thread类（包含了匿名内部类的方式）

上面演示快速上手一个线程就属于继承Thread类

• 通过继承Thread类，并重写它的run方法，我们就可以创建一个线程。
• 首先定义一个类来继承Thread类，重写run方法。
• 然后创建这个子类对象，并调用start方法启动线程。

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello,world..");
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t=new MyThread();
        t.start();
    }
}

用匿名内部类的方式：

public class ThreadDemo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(){
            @Override
            public void run() {
                    System.out.println("hello,world");
               }
        };
        t.start();
    }
}

2.实现Runnable接口（包含了匿名内部类的方式）

• 通过实现Runnable，并实现run方法，也可以创建一个线程
• 首先定义一个类实现Runnable接口，并实现run方法。
• 然后创建Runnable实现类对象，并把它作为target传入Thread的构造函数中。
• 最后调用start方法启动线程。

class MyThread3 implements Runnable {
    @Override
    public void run() {
        System.out.println("hello,线程");
    }
}
public class ThreadDemo3 {
    public static void main(String[] args) throws InterruptedException {

        Thread t= new Thread(new MyThread3());
        t.start();
    }
}

用匿名内部类的方式：

public class ThreadDemo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                    System.out.println("hello,world");
            }
        });
        t.start();
    }
}

3.实现 Callable 接口，并结合 Future 实现

• 首先定义一个 Callable 的实现类，并实现 call 方法。call 方法是带返回值的。
• 然后通过 FutureTask 的构造方法，把这个 Callable 实现类传进去。
• 把 FutureTask 作为 Thread 类的 target ，创建 Thread 线程对象。
• 通过 FutureTask 的 get 方法获取线程的执行结果。

public class ThreadDemo36 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int result=0;
                for(int i=0;i<500;i++){
                    result++;
                }
                return result;
            }
        };
        FutureTask<Integer>futureTask=new FutureTask<>(callable);
        Thread t=new Thread(futureTask);
        t.start();
        System.out.println(futureTask.get());

    }
}

Runnable关注的是这个过程，不关注执行结果。Runnable提供的run方法，返回值类型是void

Callable要关注执行结果，Callable提供的call方法，返回值就是线程执行任务得到的结果。

Callable是一个“锦上添花”的东西，它能干的事情，使用Runnable也能干。对于这种带有返回值的任务，使用Callable会更好一些。代码更直观，更简单。

4.基于lambda

使用java8的Lambda表达式创建一个匿名的Runnable对象作为线程

public class ThreadDemo6 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
               System.out.println("hello,world");
           }
        });
        t.start();
}
}

5.基于线程池

此处用 JDK 自带的 Executors 来创建线程池对象。

• 首先，用一个 Runnable 的匿名内部类，重写 run 方法。
• 然后创建一个拥有固定线程数的线程池。
• 最后通过 ExecutorService 对象的 execute 方法传入线程对象。

public class ThreadDemo32 {
    public static void main(String[] args) {
        // 使用Executors工具类创建一个线程池，这里创建的是一个固定大小的线程池
        // newFixedThreadPool方法接受一个整数参数，表示线程池中的线程数量
        // 在本示例中，创建了一个包含4个线程的固定大小线程池
        ExecutorService service = Executors.newFixedThreadPool(4);
        // 向刚刚创建的线程池提交一个任务，任务以匿名内部类的形式实现了Runnable接口
        service.submit(new Runnable() {
            // 实现Runnable接口中的run方法，这个方法定义了任务具体要执行的内容
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
        // 注意：这里缺少了关闭线程池的操作

    }
}

为什么说创建线程的方式只有一种也是可以的呢？

因为所有的方式的本质都是 new Thread()

这里不作过多解释，只因为博主也没有深入了解，所以不敢瞎说

大家可以去搜索一番