Java创建线程的七种方法，全网最全面总结~

野性酷女 2023-09-23 23:51 30阅读 0赞

**目录**

前言

一、继承Thread，重写run方法

二、实现Runnable接口，重写run方法

三、使用匿名内部类创建 Thread 子类对象

四、使用匿名内部类，实现Runnable接口

五、lambda表达式

六、实现Callable接口

七、使用线程池创建线程

--------------------

# 前言 #

属于基础的面试问题，一定要能够回答全哦~

--------------------

# 一、继承Thread，重写run方法 #

通过自定义一个类（这里起名为：MyThread），继承Thread类，重写run方法，最后在main方法中new出MyThread实例，调用这个实例的继承的Thread类的start方法创建一个线程。

> Ps：

1.创建出MyThread实例，并不代表在系统真的创建一个线程，只有调用start方法时，才创建出一个新的线程，新线程会执行run里的逻辑，直到run里逻辑执行完，线程就结束了；

2.运行一次Java程序就启动了一个进程，一个**进程**里至少会有一个**线程**，这里JVM默认创建的线程就是main线程（主线程），main主线程和MyThread创建出来的新线程是“并发执行”的关系（并发+并行），也可以理解为同时执行，各执行各的；

3.直接调用run并没有创建线程，只是在原来的线程中执行代码；

> 代码如下：

class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("继承Thread，重写run方法创建线程");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            MyThread myThread = new MyThread();
            myThread.start();
        }
    }

--------------------

# 二、实现Runnable接口，重写run方法 #

通过自定义一个类（这里起名为：MyRunnable）实现Runnable接口，重写run方法，最后在main方法new出MyRunnable实例和Thread实例，最后通过start方法创建并启动线程。

> 通俗理解：

这里相当于把线程要干的活和线程本身分离开了，使用MyRunnable这个自定义的类来表示“线程要完成的任务”，这样做的目的就是为了“解耦合”，假设未来有新的任务需要线程去执行，那么通过这种方式，代码改动就比较小。

> 代码如下：

class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("实现Runnable接口，重写run方法");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
        }
    }

--------------------

# 三、使用匿名内部类创建 Thread 子类对象 #

直接创建Thread子类，同时实例化出一个对象，重写run方法，最后通过start方法创建并启动线程。

> 代码如下：

public class Main {
        public static void main(String[] args) {
            Thread thread = new Thread() {
                @Override
                public void run() {
                    System.out.println("使用匿名内部类创建 Thread 子类对象");
                }
            };
            thread.start();
        }
    }

--------------------

# 四、使用匿名内部类，实现Runnable接口 #

通过使用使用匿名内部类，实现Runnable接口作为Thread构造方法的参数，最后通过start创建并启动线程；

> 代码如下：

public class Main {
        public static void main(String[] args) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("使用匿名内部类，实例Runnable接口作为构造参数");
                }
            });
            thread.start();
        }
    }

--------------------

# 五、lambda表达式 #

lambda本质上就是一个“匿名函数”，()表示函数的形参，\{\}表示函数体，->特殊语法，表示它是lambda表达式(->是从C++那里抄来的)。

> 代码如下：

public class Main {
        public static void main(String[] args) {
            Thread thread = new Thread(() -> {
               System.out.println("使用lambda表示创建线程");
            });
            thread.start();
        }
    
    }

--------------------

# 六、实现Callable接口 #

通过自定义类（这里起名为：MyCallable），实现Callable接口，重写call方法（call方法可以理解为线程需要执行的任务），并且带有返回值，这个返回表示一个计算结果，如果无法计算结果，则引发Exception异常，如下源码英文解释：

![6b6c71e79ea7487d9b63fc838e1299e4.png][]

接着创建Callable实例，使用FutrueTast类包装Callable对象，FutureTask是一个包装器，需要接收Callable实例来创建，并且有两个构造函数，一个参数只有Callable对象，另一个参数不仅有Callable对象，还有一个泛型的result参数，详细解释如下源码：

![e0a67d1e20f24ad485dd97bae31260be.png][]

![04918ce5cd6946eca4aa948bae07dd76.png][]

最后使用FutureTask对象作为Thread的构造参数，通过start方法创建并启动线程；

**注意：这里可以用get方法获取线程执行后的返回值。**

> 代码如下：

class MyCallableTest implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            System.out.println("创建线程:" + Thread.currentThread().getName());
            return 2;
        }
    }
    
    public class Main {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            FutureTask<Integer> task = new FutureTask<>(new MyCallableTest());
            Thread thread = new Thread(task);
            thread.start();
            System.out.println("创建线程的返回结果为:" + task.get());
        }
    
    }

--------------------

# 七、使用线程池创建线程 #

在Java中，线程池的本体叫[ThreadPoolExecutor][]，他的构造方法写起来十分麻烦，为了简化构造方法，标准库就提供了一系列工厂方法，简化使用；

> 什么是工厂模式？

工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系；

也就是说这里创建线程池没有显式new，而是通过Executors这个静态方法newCaChedThreadPool来完成的；

> 常见用法：

线程池的单纯使用很简单，使用submit方法，把任务提交到线程池中即可，线程池中会有线程来完成这些任务；

> 代码如下：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Pool {
        public static void main(String[] args) {
            ExecutorService pool = Executors.newCachedThreadPool();
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    //执行业务逻辑
                    for(int i = 1; i <= 100; i++) {
                        System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");
                    }
                }
            });
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    //执行业务逻辑
                    for(int i = 101; i <= 200; i++) {
                        System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");
                    }
                }
            });
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    //执行业务逻辑
                    for(int i = 201; i <= 300; i++) {
                        System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");
                    }
                }
            });
        }
    }

当任务量达到一定程度，一个线程忙不过来时，就会发现其他线程也来帮忙辽~

![9b57dd9adf9d462da21c3297e3ee9d95.png][]

--------------------

![b1c56c54465642a89aa0dfebed839fe8.gif][]

[6b6c71e79ea7487d9b63fc838e1299e4.png]: https://img-blog.csdnimg.cn/6b6c71e79ea7487d9b63fc838e1299e4.png
[e0a67d1e20f24ad485dd97bae31260be.png]: https://img-blog.csdnimg.cn/e0a67d1e20f24ad485dd97bae31260be.png
[04918ce5cd6946eca4aa948bae07dd76.png]: https://img-blog.csdnimg.cn/04918ce5cd6946eca4aa948bae07dd76.png
[ThreadPoolExecutor]: https://so.csdn.net/so/search?q=ThreadPoolExecutor&spm=1001.2101.3001.7020
[9b57dd9adf9d462da21c3297e3ee9d95.png]: https://img-blog.csdnimg.cn/9b57dd9adf9d462da21c3297e3ee9d95.png
[b1c56c54465642a89aa0dfebed839fe8.gif]: https://img-blog.csdnimg.cn/b1c56c54465642a89aa0dfebed839fe8.gif