深入浅出 JAVA 之线程 - Thread 详解

 1public class CreateThreadDemo {
 2
 3    public static void main(String[] args) {
 4        // 创建线程
 5        Thread thread = new Thread(new Runnable() {
 6            @Override
 7            public void run() {
 8                System.out.println(Thread.currentThread().getName() + "--线程启动");
 9            }
10        });
11        // 设置线程名称
12        thread.setName("测试线程");
13        // 启动线程
14        thread.start();
15    }
16
17}

 1public class InterruptThreadDemo {
 2
 3    public static void main(String[] args) throws InterruptedException {
 4        // 创建线程
 5        Thread myThread = new Thread(new Runnable() {
 6            @Override
 7            public void run() {
 8                // 循环执行任务，每次执行前判断当前线程是否被中断
 9                while (!Thread.currentThread().isInterrupted()) {
10                    try {
11                        System.out.println("线程正在运行...");
12                        // 线程睡眠 1 秒钟
13                        TimeUnit.SECONDS.sleep(1);
14                    } catch (InterruptedException e) {
15                        // 如果当前线程调用了 wait 或 sleep 处于堵塞状态，那么线程调用 interrupt 方法后就会抛出 InterruptedException 异常
16                        // 所以这里需要捕获 InterruptedException 异常，捕获后需要调用 Thread.currentThread().interrupt() 方法中断线程
17                        Thread.currentThread().interrupt();
18                        System.out.println("线程被中断");
19                    }
20                }
21                System.out.println("线程结束");
22            }
23        });
24        // 启动线程
25        myThread.start();
26        // 等待 5 秒后调用 interrupt 方法 MyThread 线程中断
27        TimeUnit.SECONDS.sleep(5);
28        myThread.interrupt();
29    }
30
31}

1public class ExampleUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
2
3    public void uncaughtException(Thread thread, Throwable exception) {
4        // 处理未捕获的异常
5        System.out.println("异常捕获器-捕获异常: " + exception.getMessage());
6    }
7
8}

 1public class UncaughtExceptionHandlerDemo {
 2
 3    public static void main(String[] args) {
 4        // 创建线程，并抛出运行时异常
 5        Thread myThread = new Thread(new Runnable() {
 6            @Override
 7            public void run() {
 8                // 当前线程中抛出一个未捕获的异常
 9                throw new RuntimeException("Uncaught Exception");
10            }
11        });
12        // 设置未捕获异常的处理器
13        myThread.setUncaughtExceptionHandler(new ExampleUncaughtExceptionHandler());
14        // 启动线程
15        myThread.start();
16    }
17
18}

 1public class ThreadJoinDemo {
 2
 3    public static void main(String[] args) throws InterruptedException {
 4        //循环 5 次
 5        for (int i = 0; i < 5; i++) {
 6            // 创建线程
 7            Thread myThread = new Thread(new Runnable() {
 8                @Override
 9                public void run() {
10                    System.out.println("子线程执行完毕");
11                }
12            });
13
14            // 启动子线程
15            myThread.start();
16            // 调用join()方法
17            myThread.join();
18            System.out.println("主线程执行完毕");
19            System.out.println("-----------------------------");
20        }
21    }
22
23}

  1/**
  2 * 线程名称
  3 */
  4private volatile String name;
  5
  6/**
  7 * 线程优先级 (范围是1~10，其中1最低优先级，10是最高优先级)。
  8 */
  9private int priority;
 10
 11/**
 12 * 线程是否是守护线程
 13 * 
 14 * 注: 守护线程是一种特殊的线程，当所有非守护线程结束后，JVM 就会自动退出，而不管守护线程是否已经执行完毕。
 15 * 该变量默认为 false，即默认线程为普通线程，需要显式设置为 true 才能将线程设置为守护线程。
 16 */
 17private boolean daemon = false;
 18
 19/**
 20 * 该线程要执行的任务
 21 */
 22private Runnable target;
 23
 24/**
 25 * 线程归属组
 26 */
 27private ThreadGroup group;
 28
 29/**
 30 * 此线程的上下文 ClassLoader
 31 */
 32private ClassLoader contextClassLoader;
 33
 34/**
 35 * 创建线程时的堆栈大小 (即给新线程分配的内存大小)
 36 */
 37private final long stackSize;
 38
 39/**
 40 * 线程ID
 41 */
 42private final long tid;
 43
 44/**
 45 * 分配给线程的唯一序号，JVM 会通过该序号对进程进行调度和管理。
 46 */
 47private static long threadSeqNumber;
 48
 49/**
 50 * 线程状态
 51 */
 52private volatile int threadStatus;
 53
 54/**
 55 * 阻塞线程的对象
 56 * 
 57 * 当一个线程被 park 阻塞时，JVM 会将 parkBlocker 设置为阻塞线程的对象。
 58 * 在 unpark 对线程进行唤醒时，JVM 会将 parkBlocker 清空。
 59 * 
 60 * 该变量是 volatile 类型的，因为它需要保证阻塞线程和唤醒线程之间的可见性，
 61 * 即在多线程操作时可以及时地感知到 parkBlocker 的变化。
 62 */
 63volatile Object parkBlocker;
 64
 65/**
 66 * 中断线程时所阻塞的对象
 67 * 
 68 * 当一个线程被中断时，如果该线程正在等待某个资源或者处于阻塞状态，那么 JVM 会将 blocker 设置为相应的资源或阻塞对象，
 69 * 从而使得该线程在中断处理程序中能够快速地被唤醒。
 70 * 
 71 * 这个 blocker 变量是 volatile 类型的，是为了保证在多线程操作时的可见性。
 72 */
 73private volatile Interruptible blocker;
 74
 75/**
 76 * 锁住 blocker 和 parkBlocker 两个变量的锁对象
 77 */
 78private final Object blockerLock = new Object();
 79
 80/**
 81 * 线程最小优先级。
 82 */
 83public static final int MIN_PRIORITY = 1;
 84
 85/**
 86 *  线程默认优先级
 87 */
 88public static final int NORM_PRIORITY = 5;
 89
 90/**
 91 * 线程最大优先级
 92 */
 93public static final int MAX_PRIORITY = 10;
 94
 95/**
 96 * 存储线程的局部变量
 97 * 
 98 * ThreadLocal 是一种线程局部变量，它提供了一种在多线程环境下保持变量的副本独立性的方法。每个线程都有
 99 * 一个 ThreadLocalMap 对象，用于存储该线程的所有 ThreadLocal 变量和对应的值，每个 ThreadLocal 变量
100 * 都是线程私有的，即每个线程都有自己的一份副本，不会被其他线程所访问或修改。
101 * 
102 * 使用 ThreadLocal 变量时，可以通过 get() 和 set() 方法来获取或设置当前线程的变量值。
103 * ThreadLocal 通常被用于实现线程安全的单例模式和避免线程之间的变量共享等场景。
104 */
105ThreadLocal.ThreadLocalMap threadLocals = null;
106
107/*
108 * 存储可以被子线程继承的线程局部变量。
109 * 
110 * 它是 ThreadLocal 的一个改进版本，能够保证线程的子孙线程都可以访问到线程局部变量的值，而不仅仅是当前线程。
111 * 原理与 ThreadLocal 相同，每个线程都有自己的一份副本。
112 * 
113 * 在使用 InheritableThreadLocal 时，只需将变量声明为 static final 类型即可，即可被所有子线程继承，并且
114 * 可以在子线程中修改它的值，对父线程不会产生影响。
115 * 
116 * 子线程创建时，会自动将父线程中 InheritableThreadLocal 的值复制过来。通过继承，InheritableThreadLocal 可
117 * 以在一定程度上降低并发编程难度，并且使代码更加简洁。
118 */
119ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

 1/**
 2 * 启动线程
 3 *
 4 * @throws IllegalThreadStateException 如果线程已经启动则抛出非法线程状态异常
 5 */
 6public synchronized void start() {
 7    // 如果线程状态不为 0，则说明线程已经启动过，则抛出非法线程状态异常
 8    if (threadStatus != 0) {
 9        throw new IllegalThreadStateException();
10    }
11    // 通知组该线程即将启动，以便可以将其添加到组的线程列表中，并且可以减少组的未启动计数。
12    group.add(this);
13    // 设置启动状态
14    boolean started = false;
15    try {
16        // 启动线程，该方法是启动线程的核心方法
17        start0();
18        // 如果它成功启动线程则将 started 标志设置为 true
19        started = true;
20    } finally {
21        try {
22            // 如果 started=false，则表明线程启动失败
23            // 则将调用线程组的 threadStartFailed() 方法来处理这个失败的线程
24            if (!started) {
25                group.threadStartFailed(this);
26            }
27        } catch (Throwable ignore) {
28        }
29    }
30}
31
32/**
33 * 启动线程的关核心方法
34 * 
35 * 该方法是启动线程的核心方法，是一个 Native 方法，即底层实现是由操作系统提供的，
36 * Java 虚拟机对该方法进行了封装提供给 Java 开发者使用。该方法执行时，会在底层操作
37 * 系统中创建一个新的线程，并将 Java 对象和操作系统中的线程关联起来，从而启动该线程。
38 */
39private native void start0();

1/**
2 * 运行线程中的业务逻辑
3 */
4public void run() {
5    if (target != null) {
6        target.run();
7    }
8}

1/**
2 * 使正在执行的线程等待，使调用当前 join() 方法线程先行执行，直至线程执行结束使之前正在执行的线程恢复。
3 *
4 * @throws InterruptedException 如果当前线程被中断，则会抛出 InterruptedException 异常，并清除当前线程的中断状态。
5 */
6public final void join() throws InterruptedException {
7    join(0);
8}

 1/*
 2 * 使正在执行的线程等待，使调用当前 join() 方法线程先行执行，在指定时间(毫秒)后使之前正在执行的线程恢复。
 3 *
 4 * @param millis 休眠时间(毫秒)
 5 * @throws IllegalArgumentException 如果传入的毫秒数是负数，会抛出 IllegalArgumentException 异常。
 6 * @throws InterruptedException     如果当前线程被中断，则会抛出 InterruptedException 异常，并清除当前线程的中断状态。
 7 */
 8public final synchronized void join(long millis) throws InterruptedException {
 9    long base = System.currentTimeMillis();
10    long now = 0;
11
12    if (millis < 0) {
13        throw new IllegalArgumentException("timeout value is negative");
14    }
15
16    if (millis == 0) {
17        while (isAlive()) {
18            wait(0);
19        }
20    } else {
21        while (isAlive()) {
22            long delay = millis - now;
23            if (delay <= 0) {
24                break;
25            }
26            wait(delay);
27            now = System.currentTimeMillis() - base;
28        }
29    }
30}

 1/**
 2 * 使正在执行的线程等待，使调用当前 join() 方法线程先行执行，在指定时间(毫秒/纳秒)后使之前正在执行的线程恢复。
 3 *
 4 * @throws InterruptedException
 5 * @param millis 休眠时间(毫秒)
 6 * @param nanos  休眠时间(纳秒)
 7 * @throws IllegalArgumentException 如果传入的毫秒数是负数，会抛出 IllegalArgumentException 异常。
 8 * @throws InterruptedException     如果当前线程被中断，则会抛出 InterruptedException 异常，并清除当前线程的中断状态。
 9 */
10public final synchronized void join(long millis, int nanos) throws InterruptedException {
11
12    if (millis < 0) {
13        throw new IllegalArgumentException("timeout value is negative");
14    }
15
16    if (nanos < 0 || nanos > 999999) {
17        throw new IllegalArgumentException(
18                            "nanosecond timeout value out of range");
19    }
20
21    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
22        millis++;
23    }
24
25    join(millis);
26}

 1/**
 2 * 使当前线程中断
 3 */
 4public void interrupt() {
 5    // 判断当前线程是否等于当前线程对象
 6    if (this != Thread.currentThread()) {
 7        // 检查当前线程是否有权限修改这个线程对象
 8        checkAccess();
 9
10        // 使用 synchronized 锁保证只有一个线程执行下面操作
11        synchronized (blockerLock) {
12            // 获取当前线程正在阻塞的对象(如果有的话)，将其保存在局部变量 b 中
13            Interruptible b = blocker;
14            // 判断当前线程是否正在进行 I/O 操作阻塞，如果是则调用 interrupt0() 将当前线程的中断状态设置为 true，
15            // 并将中断信息发送给正在阻塞的对象。
16            if (b != null) {
17                interrupt0();
18                b.interrupt(this);
19                return;
20            }
21        }
22    }
23
24    // 将当前线程的中断状态设置为 true，表示当前线程已经被中断。
25    interrupt0();
26}

1/**
2 * 使当前线程在接下来的时间(毫秒)内进行休眠。
3 * (注: 休眠的精度和准确性受系统定时器和调度器的影响，并且在休眠期间线程不会释放锁)
4 *
5 * @param millis 休眠时间(毫秒)
6 * @throws IllegalArgumentException 如果传入的毫秒数是负数，会抛出 IllegalArgumentException 异常。
7 * @throws InterruptedException     如果当前线程被中断，则会抛出 InterruptedException 异常，并清除当前线程的中断状态。
8 */
9public static native void sleep(long millis) throws InterruptedException;

 1/**
 2 * 使当前线程在接下来的时间(毫秒/纳秒)内进行休眠。
 3 * (注: 休眠的精度和准确性受系统定时器和调度器的影响，并且在休眠期间线程不会释放锁)
 4 *
 5 * @param millis 休眠时间(毫秒)
 6 *  @param nanos 休眠时间(纳秒)
 7 * @throws IllegalArgumentException 如果传入的毫秒数是负数，会抛出 IllegalArgumentException 异常。
 8 * @throws InterruptedException     如果当前线程被中断，则会抛出 InterruptedException 异常，并清除当前线程的中断状态。
 9 */
10public static void sleep(long millis, int nanos) throws InterruptedException {
11    if (millis < 0) {
12    throw new IllegalArgumentException("timeout value is negative");
13    }
14
15    if (nanos < 0 || nanos > 999999) {
16    throw new IllegalArgumentException(
17    "nanosecond timeout value out of range");
18    }
19
20    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
21    millis++;
22    }
23
24    sleep(millis);
25}

1/**
2 * 检查当前线程是否中断，并将中断状态清除。
3 *
4 * @return 如果当前线程已被中断则返回 true，否则返回 false。
5 */
6public static boolean interrupted() {
7    return currentThread().isInterrupted(true);
8}

1/**
2 * 检查线程的是否中断，且不清除中断状态。
3 *
4 * @return 如果当前线程已被中断则返回 true，否则返回 false。
5 */
6public boolean isInterrupted() {
7    return isInterrupted(false);
8}

1/**
2 * 获取当前活动线程的数量。
3 *
4 * @return 获取当前活动线程的数量。
5 */
6public static int activeCount() {
7    return currentThread().getThreadGroup().activeCount();
8}

1/**
2 * 获取系统中的所有线程，并将它们存储在 tarray 数组中，然后返回数组中的线程数量。
3 *
4 * @param tarray 用于存储线程的数组
5 * @return 储在 tarray 数组中的线程数
6 */
7public static int enumerate(Thread tarray[]) {
8    return currentThread().getThreadGroup().enumerate(tarray);
9}