目录

方法1 ：继承Thread类，重写run方法，调用 start 方法启动

方法2 ：实现Runnable接口，重写run方法，调用 start 方法启动

方法3：匿名内部类 创建Thread 子类对象

方法4：匿名内部类 创建Runnable子类对象

方法5：使用 lambda 表达式 创建Runnable 子类对象

方法6：使用线程池！！！ 重点

方法7：使用Callable！！！重点

---

如果觉得有用，记得三连哦！

方法1 ：继承Thread类，重写run方法，调用 start 方法启动

    public static void main(String[] args) {
        class MyThread extends Thread{
            @Override
            public void run() {
                System.out.println("成功创建线程！");
            }
        }
        MyThread thread = new MyThread();
        thread.start();
    }

方法2 ：实现Runnable接口，重写run方法，调用 start 方法启动

public static void main(String[] args) {
        class MyRunnable implements Runnable {
            @Override
            public void run() {
                System.out.println("成功创建线程！");
            }
        }
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable,"继承Runnable接口实现");
        thread.start();
    }

方法3：匿名内部类 创建Thread 子类对象

    public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println("成功创建线程！");
            }
        };
        thread.start();
    }

方法4：匿名内部类 创建Runnable子类对象

public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("成功创建线程!");
            }
        });
        thread.start();
    }

方法5：使用 lambda 表达式 创建Runnable 子类对象

public static void main(String[] args) {
        Thread thread= new Thread(()->{
            System.out.println("成功创建线程!");
        });
        thread.start();
    }

方法6：使用线程池

创建线程池：

1. 使用 Executors.newFixThreadPool ( )  创建固定线程数的线程池

2.返回值的类型为 ExecutorService

3. 通过ExecutorsSercvice. submit 可注册一个任务到线程池中

例如：

public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        pool.submit(()->{
            System.out.println("一个在 线程池 中的线程 创建完成！");
        });
    }

Executors 创建线程线程池的一些方式（工厂方法)：

1. newFixedThreadPool 创建固定线程数的线程池

2. newCachedThreadPool 创建线程数动态增长的线程池

3. newSingleThreadExecutor 创建只包含一个线程的线程池

4. newScheduledThreadPool 设定延迟时间后执行命令，或者定期执行（增强版的Timer)

方法7：使用Callable

什么是Callable?（带返回值的Runnable)

都是描述一个"任务" ，但是Callable 带有返回值，Runnable不带返回值。Callable 也是一个 interface。相当于把线程封装了一个“返回值”，方便程序员 借助多线程计算结果。

Callable 通常搭配 FutureTask 使用，FutureTask 的作用是用来保存Callable的返回值。FutureTask负责等待这个结果出来，但其实啥时候出来结果是不确定的（FutureTask就相当于我们点餐时候，收银员给的一个小票，Callable在后台做食物，我们拿着小票去领)

例子：创建线程计算1+2+3+4+ .......+1000

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建一个 callable 相当于 Runnable，但有了返回值 sum
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };
        //2. 创建一个FutureTask，task用来接收返回值
        //这里的返回值就相当于一个小票！即便这里的相加还没有开始
        FutureTask task = new FutureTask(callable);
        //3. 创建一个线程开始工作！进行相加！
        Thread t = new Thread(task);
        t.start();
        //4. 线程里的 Callable 任务完成！返回值被赋给 task
        //可以通过 task 里的 get() 方法获取到返回值！
        System.out.println(task.get());
    }