线程的常用方法

[1. 获取当前线程 - Thread.currentThread()](#1. 获取当前线程 - Thread.currentThread())

[2. 线程命名 - setName() 和 getName()](#2. 线程命名 - setName() 和 getName())

[3. 线程休眠 - Thread.sleep()](#3. 线程休眠 - Thread.sleep())

[4. 线程插队 - join()](#4. 线程插队 - join())

[5. 启动线程 - start()](#5. 启动线程 - start())

[6. 中断线程 - interrupt()](#6. 中断线程 - interrupt())

[7. 线程优先级 - setPriority() 和 getPriority()](#7. 线程优先级 - setPriority() 和 getPriority())

[8. 守护线程 - setDaemon()](#8. 守护线程 - setDaemon())

[9. 线程状态检查](#9. 线程状态检查)

1. 获取当前线程 - Thread.currentThread()

作用：

静态方法，返回当前正在执行的线程对象

可以在任何地方调用，获取当前执行环境的线程

2. 线程命名 - setName() 和 getName()

默认命名规则：

主线程："main"

子线程："Thread-0", "Thread-1", ...

示例代码：

java 复制代码

package ThreadAPI;

public class Demo1 {

    public static void main(String[] args) {
        // 哪个线程调用的这个代码，这个代码就拿到哪个线程的名字
        // 主线程名字叫做main
        Thread m = Thread.currentThread();  // 🔑 获取当前线程对象
        m.setName("主线程");                // 🔑 设置线程名称

        // 创建并启动第一个线程
        Thread t1 = new MyThread();
        t1.setName("1号线程");              // 🔑 设置线程名称
        t1.start();                        // 🔑 启动线程

        // 创建并启动第二个线程
        Thread t2 = new MyThread();
        t2.setName("2号线程");
        t2.start();

        // 主线程执行的任务
        for (int i = 0; i < 6; i++) {
            System.out.println("Main方法输出:" + i);
        }

        // 输出线程名称
        System.out.println(m.getName());   // 🔑 获取线程名称
        System.out.println(t1.getName());
        System.out.println(t2.getName());
    }
}

class MyThread extends Thread {
    public void run() {
        // 🔑 在子线程中获取当前线程对象及其名称
        for (int i = 0; i < 6; i++) {
            System.out.println(MyThread.currentThread().getName() + "输出:" + i);
        }
    }
}

线程休眠 - Thread.sleep()

特性：

静态方法：让当前线程休眠指定时间

不会释放锁：如果持有锁，休眠期间仍然持有

单位：毫秒（1秒 = 1000毫秒）

必须捕获异常：InterruptedException

精确性：不保证精确时间，受系统调度影响

应用场景：

定时任务

模拟网络延迟

控制执行节奏

避免CPU空转

代码：

java 复制代码

package ThreadAPI;

/**
 * sleep方法(线程休眠)
 */
public class Demo2 {

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
            try {
                // 🔑 让当前线程休眠1000毫秒（1秒）
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4. 线程插队 - join()

代码：

java 复制代码

package ThreadAPI;

/**
 * join方法
 */
public class Demo3 {
    // 搞清楚线程的join方法：让调用这个方法的线程先执行完(线程插队)
    public static void main(String[] args) {
        MyThread2 m1 = new MyThread2();
        m1.start();
        
        for (int i = 1; i < 5; i++) {
            System.out.println("主线程输出：" + i);
            if (i == 1) {
                try {
                    // 🔑 让m1线程先执行完，再执行主线程
                    m1.join();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class MyThread2 extends Thread {
    public void run() {
        for (int i = 1; i < 5; i++) {
            System.out.println(ThreadAPI.MyThread.currentThread().getName() + "输出:" + i);
        }
    }
}

三种重载形式：

java 复制代码

void join()                    // 无限期等待，直到线程结束
void join(long millis)         // 最多等待指定毫秒数
void join(long millis, int nanos) // 更精确的时间控制

执行效果：

java 复制代码

原始执行顺序：
主线程：输出1 → 输出2 → 输出3 → 输出4
子线程：输出1 → 输出2 → 输出3 → 输出4

使用join()后
主线程：输出1 → [等待子线程] → 输出2 → 输出3 → 输出4
子线程：输出1 → 输出2 → 输出3 → 输出4（优先执行完毕）

应用场景：

等待子线程完成后再继续主线程

多个线程协同工作，需要顺序执行

汇总多个线程的结果

启动线程 - start()

java 复制代码

Thread t1 = new MyThread();
t1.start();  // 正确：启动新线程，由JVM调用run()

// 错误示例：
t1.run();    // 错误：只是普通方法调用，不会创建新线程

特点：

只能调用一次，多次调用会抛 IllegalThreadStateException

真正创建新线程执行

6. 中断线程 - interrupt()

java 复制代码

Thread t = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 正常执行任务
    }
    System.out.println("线程被中断");
});
t.start();

// 一段时间后中断线程
Thread.sleep(1000);
t.interrupt();

7. 线程优先级 - setPriority() 和 getPriority()

java 复制代码

Thread t1 = new Thread();
t1.setPriority(Thread.MAX_PRIORITY);  // 10
t1.setPriority(Thread.NORM_PRIORITY); // 5（默认）
t1.setPriority(Thread.MIN_PRIORITY);  // 1

System.out.println(t1.getPriority());  // 获取优先级
注意：优先级只是建议，实际调度由操作系统决定

8. 守护线程 - setDaemon()

java 复制代码

Thread daemonThread = new Thread(() -> {
    while (true) {
        System.out.println("守护线程运行中...");
        Thread.sleep(1000);
    }
});
daemonThread.setDaemon(true);  // 设置为守护线程
daemonThread.start();

主线程结束后，守护线程会自动结束

特点：

为其他线程提供服务

当所有用户线程结束时，守护线程自动结束

不能手动设置为守护线程后再启动（setDaemon() 必须在 start() 前调用）

9. 线程状态检查

java 复制代码

Thread t = new Thread();
System.out.println(t.getState());  // NEW（新建状态）

t.start();
System.out.println(t.getState());  // RUNNABLE（可运行状态）

Thread.sleep(100);
System.out.println(t.getState());  // TIMED_WAITING（定时等待状态）

线程状态：

NEW：新建，未启动

RUNNABLE：可运行或正在运行

BLOCKED：阻塞（等待锁）

WAITING：无限期等待

TIMED_WAITING：定时等待

TERMINATED：终止