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

更新时间：2023年05月19日 14:02:33 作者：陈亦康

线程是Java中的基本执行单元,它允许程序在同一时间执行多个任务,下面这篇文章主要给大家总结介绍了关于Java创建线程的七种方法,文中通过实例代码将这七种方法介绍的非常详细,需要的朋友可以参考下

前言

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

一、继承Thread，重写run方法

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

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异常，如下源码英文解释：

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

最后使用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 + "~");
                }
            }
        });
    }
}

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

总结

到此这篇关于Java创建线程的七种方法总结的文章就介绍到这了,更多相关Java创建线程方法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

java实现emqx设备上下线监听详解
这篇文章主要为大家介绍了java实现emqx设备上下线监听详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-07-07
值得收藏！教你如何在IDEA中快速查看Java字节码
开发中如果我们想看JVM虚拟机怎么编译我们的Java文件,生成字节码的,用IDEA工具就可以查看,本篇文章就给大家详细介绍,对正在学习java的小伙伴们很有帮助,需要的朋友可以参考下
2021-05-05
Java实现企业微信消息推送功能的详细步骤
这篇文章主要介绍了Java实现企业微信消息推送功能,本文图文实例代码相结合给大家介绍的非常详细，需要的朋友可以参考下
2022-04-04
SpringMvc响应数据及结果视图实现代码
这篇文章主要介绍了SpringMvc响应数据及结果视图实现代码,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-08-08
java如何交换这两个变量的值方法介绍
在编程中可能会使用java来完成两个变量值的交换，本文将介绍如何解决此类问题，希望可以帮助您
2012-11-11
Java中的volatile关键字原理深入解析
这篇文章主要介绍了Java中的volatile关键字原理深入解析,volatile是Java 编程语言允许线程访问共享变量,为了确保共享变量能被准确和一致地更新,线程应该确保通过排他锁单独获得这个变量,需要的朋友可以参考下
2023-12-12
Java多线程知识点全面总结
这篇文章主要介绍了Java多线程知识点全面总结，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-03-03
Eclipse git推送上传错误问题解决方案
这篇文章主要介绍了Eclipse git推送上传错误问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-09-09
Mybatis 中如何判断集合的size
这篇文章主要介绍了在Mybatis中判断集合的size操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2021-02-02
SpringBoot+Vue+Element-ui实现前后端分离
使用前后端分离的方式，可以减少代码耦合，本文主要介绍了SpringBoot+Vue+Element-ui实现前后端分离，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-06-06