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

一、多线程基础概念

在正式进入线程创建的话题前，先来快速捋一遍几个关键概念。这些是后续所有多线程代码的底层支撑，理解了它们，写起代码来心里才有谱。

1. 线程与进程的关系

• 线程是轻量级进程，进程则是重量级进程。打个比方，进程是工厂，线程就是工厂里的流水线。
• 进程是操作系统资源分配的基本单位，而线程是操作系统调度执行的基本单位。一个进程想跑起来，至少得有一个线程。
• 进程之间不会相互影响——一个进程挂了，别的进程照常运行。但线程可能会相互影响，因为它们共享进程的堆内存、文件描述符等资源。
• 进程内部包含线程，同一个进程的多个线程之间共享同一份资源。所以多线程天然就“通信方便”，但也容易打架（并发安全问题）。
• 线程创建不需要申请系统资源，销毁也不需要释放资源，相比进程开销小得多。这也是为什么高并发场景下我们大量使用线程而非进程。
• CPU发展遇到瓶颈后，厂商转向多核心，于是多线程编程成了充分利用多核的唯一方式。

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

• sleep让当前线程进入阻塞状态（暂停执行指定时间）。注意是“阻塞”不是“睡眠”——其实用休息更形象。

3. 方法重写要求

• 父类方法和子类方法，签名必须完全一致，包括方法名、参数列表、声明的抛出异常……一个字符都不能差。

二、线程创建的几种写法

很多新手一开始会被这么多创建方式绕晕，其实每种写法都有它的适用场景。下面从最原始的继承Thread开始，逐步过渡到更简洁的lambda表达式。

写法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);
        }
    }
}

步骤：

1. 创建 Thread 的子类（匿名内部类，没有类名）。
2. 重写 run。
3. 创建 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 语法一直很死板，早期必须依托类才能执行逻辑，所以先搞了个匿名内部类作为过渡，后来才引入 lambda。
• 函数式接口（如 Runnable）才能用 lambda 简化，因为接口里只有一个抽象方法，编译器能自动推断。

三、常见面试题：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.*; 可以导入包中所有类（但一般不推荐，容易拖慢编译并造成模糊引用）。
• 最基础、最常用的包是 java.lang.*，编译器会自动导入，所以 String、System 这些类可以直接用，不需要显式 import。