面试必考！！！！！创建线程池的方法有哪些？？？有什么区别？？？

线程的创建方式及其区别：

在面试中，经常会被问道“java创建线程的方法有哪些呢·？都有什么区别呢？”

---

创建方式：

• 继承Thread
• 实现Runnable
• 实现Callable并使用futuretask包装
• 使用匿名内部类
• 使用线程池
• 使用Lambda表达式（java8及其以上）

---

代码：

继承Thread

package CreateThread;

public class ThreadCreate {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();

    }
}
class MyThread extends Thread{
    public void run() {
        System.out.println("Thread is running...");
    }
}

实现Runnable

package CreateThread;

public class RunnableCreate {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.run();
    }

}

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running...");
    }
}

实现Callable并使用futuretask

package CreateThread;

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

public class CallableCreate {
    public static void main(String[] args) {
        // 创建Callable实现类的实例
        Callable<String> callable = new MyCallable();

        // 创建FutureTask对象，用于包装Callable对象
        FutureTask<String> futureTask = new FutureTask<>(callable);

        // 创建线程并启动
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            // 获取线程执行结果
            String result = futureTask.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }




    }
}
class  MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "创建Callable";
    }
}

使用匿名内部类

package CreateThread;

public class NiMingNeiBuClassCreate {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程启动");
            }
        });
        thread.run();
    }
}

使用线程池

package CreateThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExecutorCreate {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("创建线程" +  Thread.currentThread().getName() + "执行任务" + i);

            }
        });
        executorService.submit(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("创建线程" +  Thread.currentThread().getName() + "执行任务" + i);

            }
        });
        executorService.submit(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("创建线程" +  Thread.currentThread().getName() + "执行任务" + i);

            }
        });


    }
}

使用lambda表达式

package CreateThread;

public class LambdaCreate {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("启动");
        });
        thread.run();
    }
}

区别：

继承Thread

优点

方便，高效，直接

缺点

java无法实现多继承，当使用继承Thread类后无法在继续继承其他的类
灵活性较差

实现Runnable

优点

优点是可以多实现，灵活性高
多个线程可以同时访问同一个线程对象

缺点

需要new一个thread对象来启动线程
接收不到返回值

实现Callable并使用futuretask

优点

可以接收到返回值
可以抛出异常，方便进行异常处理

缺点

相对复杂

使用匿名内部类

优点

缺点

使用线程池

优点

性能高，不需要进行频繁的线程创建和销毁操作
灵活性高
资源管理好，避免了系统资源的耗尽

缺点

复杂，需要定义线程池来完成操作

使用lambda表达式

优点

简洁高效

缺点

需要java 8及其以上的版本