Java线程创建的5种写法详解

更新时间：2026年05月31日 09:32:45 作者：ChaoYLuo

这段文章详细解释了线程与进程的关系、线程状态、线线程创建的几种写法、常见面试题以及高耦合与低耦合的概念,通过这些内容,读者可以全面了解线程的基础知识及其在编程中的应用,需要的朋友可以参考下

一、多线程基础概念

1. 线程与进程的关系

线程是轻量级进程，进程是重量级进程。
进程是操作系统资源分配的基本单位，线程是操作系统调度执行的基本单位。
进程之间不会相互影响，但线程可能会相互影响（因为线程共享进程资源）。
进程内部包含线程，同一个进程的多个线程之间共享同一份资源。
线程创建不需要申请资源，销毁也不需要释放资源（相比进程开销小）。
CPU发展瓶颈 → 多核心（多线程充分利用多核）。

2. 线程状态：Thread.sleep(millis: 1000)

sleep让当前线程进入阻塞状态（暂停执行指定时间）。

3. 方法重写要求

父类方法和子类方法，签名完全一致（包括：方法名、参数列表、声明的抛出异常...）。

二、线程创建的几种写法

写法1：继承Thread，重写run

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

写法2：实现Runnable，搭配Thread执行

// 1. 定义 Runnable 实现类
class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

// 2. 创建线程
public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start(); // 启动新线程，执行 Runnable 内部的 run
        
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

Runnable自身一般不会单独执行，需要搭配“载体”（Thread）执行。
不再需要重写 run（已实现在 Runnable中）。
本质：启动的新线程会执行 Runnable内部的 run方法。

写法3：继承Thread，使用匿名内部类

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start(); // 记住：调用 start 才是真正创建线程
        
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

步骤：

创建 Thread的子类（匿名内部类，无名字）。
重写 run。
创建 Thread子类的实例，并用 t引用指向。

特点：方便、一次性使用。

写法4：实现Runnable，使用匿名内部类

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

此处针对 Runnable定义匿名内部类，返回结果是一个 Runnable的引用，把这个引用传入 Thread。

写法5：【简化】lambda表达式

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

数据结构角度来看：枚举、lambda、反射。
lambda本质上是一个“匿名函数”，很多地方都能支持。
Java 语法非常死板，必须得有类；最初 Java 和其他语言都有 lambda，先搞了个匿名内部类过渡。
函数式接口（如 Runnable是函数式接口）。

三、常见面试题：Thread对象与start()的关系

问题：多次调用start()会怎样？

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        System.out.println("hello");
    });
    thread.start();
    thread.start(); // 报错！
    thread.start();
}

报错：java.lang.IllegalThreadStateException: Thread already started
原因：Java 约定，一个 Thread对象，和一个操作系统中的线程是“一一对应”关系。
因此，一个 Thread对象，只能 start一次。
后续学习 Thread上的其他方法/属性，都是控制这个对应系统中的线程。

四、补充：高耦合 vs 低耦合（生活类比）

高耦合：女朋友生病了，我推掉所有工作，全身心在医院照顾 → 假设陌生人生病了，对我没啥影响，朋友圈点赞之交，该干啥干啥，影响非常小。
低耦合：任务（Runnable）和线程（Thread）解耦 → 任务和线程概念绑定（继承 Thread）时，若改成其他形式，需要大规模修改代码；而 Runnable没有和线程概念绑定，任务可方便地迁移到其他载体上。

五、包（package）的概念

Java 中类太多（标准库、第三方库、自己写的）→ 乱。
包：一组有关系的类放到一起。
包默认情况下不会引入到代码中，使当前代码引入的类比较少、不容易乱。
import java.util.*;：导入包中所有类（不推荐）。
最基础常用的：import java.lang.*（默认导入）。

以上就是Java线程创建的5种写法详解的详细内容，更多关于Java线程创建写法的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

FeignClient支持运行时动态指定URL方式
在实际开发中,我们经常通过FeignClient接口调用三方API,当面对不同的环境对应不同的地址时,可以通过配置文件和占位符来切换,但在同一个环境中需要调用不同地址的相同接口时,这种方法就失效了,此时,可以通过实现RequestInterceptor接口来动态切换地址
2024-11-11
详谈异步log4j2中的location信息打印问题
这篇文章主要介绍了详谈异步log4j2中的location信息打印问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-12-12
IDEA使用技巧之如何将本地项目和git远程项目关联
这篇文章主要介绍了IDEA使用技巧之如何将本地项目和git远程项目关联问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-02-02
Springboot Thymeleaf模板文件调用Java类静态方法
这篇文章主要介绍了Springboot Thymeleaf模板文件调用Java类静态方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2007-09-09
Java关键字final的实现原理分析
这篇文章主要介绍了Java关键字final的实现原理分析,在JDK8之前,如果在匿名内部类中需要访问局部变量,那么这个局部变量一定是final修饰的,但final关键字可以省略,需要的朋友可以参考下
2024-01-01
java -jar 运行及日志输出过程
这篇文章主要介绍了java -jar 运行及日志输出过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2025-06-06
Java之String类型的编码方式转换
这篇文章主要介绍了Java之String类型的编码方式转换，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-02-02
20秒教你学会java List函数排序操作示例
这篇文章主要为大家介绍了20秒教你学会List函数排序操作示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-09-09
SpringBoot中进行事务回滚的方法
在Spring Boot中,可以使用TransactionTemplate或@Transactional注解来进行事务管理,本文主要介绍了SpringBoot中进行事务回滚的方法,感兴趣的可以了解一下
2023-11-11
Java中的for循环结构及实例
这篇文章主要介绍了Java中的for循环结构及实例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-01-01