Java 多线程基础：进程线程概念与 Thread 类详解

2. Java 中的线程实现：Thread 类

2.1 创建线程

构造方法如下:

1. 直接继承 Thread 类

• **优点：**实现简单，直接重写 run() 方法即可定义线程任务。
• **缺点：**线程逻辑与 Thread 类耦合，不利于代码复用；Java 单继承特性限制了扩展性，无法再继承其他类。

// Thread 类实现了 Runnable 接口，所以需要重写 run 方法
class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello MyThread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        // 启动线程
        thread.start();
    }
}

2. 实现 Runnable 接口

• **优点：**避免单继承限制，可同时实现其他接口或继承类；线程任务与 Thread 解耦，便于复用。
• **缺点：**需额外创建 Thread 类实例来启动线程，代码稍显冗余。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello MyRunnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        // 启动线程
        thread.start();
    }
}

3. 匿名内部类创建 Runnable 子类对象

• **优点：**可直接访问外部类的 final 或有效 final 变量 (变量捕获)。
• **缺点：**代码可读性较差，尤其是逻辑复杂时。

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread() {
            // 匿名内部类
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hello Thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        thread.start();
    }
}

4. lambda 表达式创建 Runnable 子类对象

• **优点：**可直接访问外部类的 final 或有效 final 变量 (变量捕获)。
• **缺点：**仅适用于接口中只有一个抽象方法的情况。

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

2.2 获取线程名字和 id

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {});
        // 获取线程 id
        System.out.println(thread.getId());
        // 获取线程 name
        System.out.println(thread.getName());
    }
}

2.3 判断线程是否存活

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        // false, 线程还没启动
        System.out.println(thread.isAlive());
        thread.start();
        // true, 线程正在执行任务
        System.out.println(thread.isAlive());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // false, 线程结束
        System.out.println(thread.isAlive());
    }
}

2.4 前台/后台线程

**前台线程：**会阻止进程终止，即使主线程执行完毕，只要存在前台线程仍在运行，进程会继续运行直到所有前台线程完成任务。默认情况下，主线程是前台线程，通过 Thread 类创建的线程默认也是前台线程。

**后台线程：**不会阻止进程终止，当所有前台线程结束时，后台线程会被自动终止，无论是否完成任务。

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                    System.out.println("Hello Thread");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        // 把 thread 设置为后台线程，不会阻止主线程的结束，thread 线程会伴随 main 线程的结束而结束
        thread.setDaemon(true);
        thread.start();
        System.out.println("Hello Main");
    }
}

**运行结果：**Hello Main

2.5 详解 start 和 run

**start 方法：**用于启动一个新线程，新线程会执行 run 方法中的代码。每个线程只能调用一次 start，重复调用会抛出 IllegalThreadStateException (无论该线程是否执行完任务)。

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        // 开启新线程，thread 线程执行 run 方法
        thread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("Hello Main");
            Thread.sleep(100);
        }
    }
}

**run 方法：**直接调用 run 方法不会创建新线程，而是在当前线程中执行 run 方法的代码。

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        // main 线程执行 run 方法
        thread.run();
        for (int i = 0; i < 5; i++) {
            System.out.println("Hello Main");
            Thread.sleep(100);
        }
    }
}

2.6 线程休眠

**Thread.sleep：**是 Java 中用于暂停当前线程执行的一个静态方法。它允许线程在指定的时间内进入休眠状态，期间不会占用 CPU 资源。休眠结束后，线程会重新进入就绪 (RUNNABLE) 状态，等待调度执行。

// 毫秒级精确度，需要处理 InterruptedException(编译时异常)
public static native void sleep(long millis) throws InterruptedException;
// 纳秒级精确度
public static void sleep(long millis, int nanos) throws InterruptedException;

**知识回顾：**main 方法中：既可以 throws 声明异常，也可以 try-catch 异常。 run 方法中：只能 try-catch 异常，因为子类重写父类方法时不能修改父类方法的方法签名。

2.7 currentThread：获取当前线程实例

在继承 Thread 类的自定义线程类中，可以通过 this 关键字直接访问当前线程的属性和方法。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(this.getId() + " " + this.getName());
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }
}

在使用 Runnable 接口或 Lambda 表达式创建线程时，无法直接使用 this 获取线程信息，因为 this 指向的是 Runnable 实例而非线程对象。应调用 Thread.currentThread() 获取当前线程的引用。

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            Thread t1 = Thread.currentThread();
            System.out.println(t1.getId() + " " + t1.getName());
        });
        thread.start();
    }
}

2.8 变量捕获

1. **Java 的线程模型：**栈帧中的局部变量是线程私有的，这意味着每个线程都有自己的栈帧，局部变量存储在栈帧中，一个线程不得访问另一个线程中的局部变量。
2. **变量捕获 (Variable Capture)：**通常与 Lambda 表达式和匿名内部类相关，允许捕获外部作用域的变量，但这些变量必须是 final 修饰或事实 final。

结合以上两点，变量捕获机制允许一个线程获取另一个线程中的 final 变量。在上述代码中，thread 线程捕获到 main 线程中的 isQuit 变量，本质上是将 isQuit 变量拷贝到 thread 线程中，而不是直接访问 main 的栈帧 (避免因变量的生命周期而可能产生的线程安全问题)。如果允许匿名内部类或 lambda 表达式访问并修改局部变量，就会导致变量逃逸 (escape)，即变量的引用或值被传递到栈帧之外造成栈中变量的内存地址泄漏，这种情况会引发严重的安全问题，因为原本被 Java 线程模型规定为线程私有的数据可能会被并发访问。

2.9 终止线程

通过修改类变量来终止线程

• **缺点：**类变量属于整个进程的公共变量，访问时需要注意线程安全问题；类变量无法唤醒线程中的 sleep 方法。

public class ThreadDemo {
    public static boolean isQuit = false;

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!isQuit) {
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("Over Thread");
        });
        thread.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        isQuit = true;
    }
}

**interrupt()：**是 Java 中用于中断线程的方法。它的核心作用是向目标线程发送一个中断信号，但并不会直接终止线程的执行。需要主动检查中断状态并决定如何响应中断。

• **interrupted()：**检查当前线程的中断状态，并清除中断标志 (即调用后中断状态会被重置为 false)。
• **isInterrupted()：**检查线程的中断状态，但不会清除中断标志 (即调用后不改变中断状态)，仅返回当前状态。

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
            System.out.println("Over Thread");
        });
        thread.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // 终止线程，并唤醒线程中的 sleep
        thread.interrupt();
    }
}

2.10 join

**join 方法：**用于等待线程执行完成。调用某个线程的 join 方法后，当前线程会被阻塞，直到目标线程执行完毕。

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("Over Thread");
        });
        thread.start();
        // main 等待 thread 线程执行完毕
        thread.join();
        // main 线程恢复执行
        System.out.println("Hello Main");
    }
}

执行结果： Hello Thread Hello Thread Hello Thread Over Thread Hello Main