探索多线程编程：线程的本质、状态和属性

在现代计算机编程中，多线程是一个重要而强大的概念。它使得我们能够更有效地利用多核处理器、提高程序性能并实现并发操作。

什么是线程

线程是程序执行的最小单元，它是操作系统调度的基本单位。与进程不同，线程共享相同的进程内存空间，这意味着它们可以访问相同的数据和资源。线程之间的通信更加轻松，但也需要更仔细的同步，以避免竞态条件和数据冲突。
每个任务在一个线程中执行，线程是控制线程的简称。一个程序同时运行多个线程，就可以称这个程序是多线程的。
我们来写一个多线程程序看一下执行结果：

public class main {
    public static void main(String[] args) {
        //构造一个新线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 200; i++) {
                    System.out.println("这是第一个线程！");
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 200; i++) {
                    System.out.println("这是第二个线程！");
                }
            }
        });
        System.out.println("线程1启动");
        //启动新线程
        t1.start();
        System.out.println("线程2启动");
        t2.start();
    }
}

通过结果我们可以看到两个线程是同时执行的。
创建线程的几种方法可以看完之前写的博客。

线程状态

线程有如下6种状态：

• New（新建）
• Runnable（可运行）
• Blocked（阻塞）
• Waiting（等待）
• Time waiting（计时等待）
• Terminated（终止）

新建线程

用new操作符创建一个新线程时，这个线程还没有开始运行。
例如：

        //构造一个新线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 200; i++) {
                    System.out.println("这是第一个线程！");
                }
            }
        });

可运行线程

当新创建的线程调用start方法后，就处于可运行状态。一个可运行的线程可能处于正在运行状态也可能没有运行。这是因为抢占式调度系统，给每一个可运行线程一个时间片来执行任务。每一个处理器运行一个线程，当线程的数目多于处理器数目时，调度器需要分配时间片，让多个线程并行运行。

阻塞和等待线程

当线程处于阻塞或者等待状态时，它是暂时不活动的。

• 线程试图获取内部的对象锁，而这个锁被其他线程占有，以至线程处于阻塞状态。
• 线程等待其他线程发出的通知或中断信号。例如调用Object.wait方法，Thread.join方法使线程进入等待状态。
• 还有就是使用Thread.sleep,Object.wait,Thread.join方法使使线程进入计时等待状态。

例如：Thread.sleep(1000);使线程等待一秒。

终止线程

• run方法正常退出，线程自然结束
• 一个没有捕获的异常终止了run方法，使线程意外终止

我们可以通过getState()得到当前线程的状态。

线程属性

线程的属性是指线程的一些特征和配置选项，它们可以影响线程的行为和性能。

优先级

优先级用于确定线程在竞争CPU时间时的优先级，即决定了线程被调度执行的概率。每个线程都有一个默认优先级，通常为普通（Normal）优先级，范围从1（最低优先级）到10（最高优先级）。线程的优先级可以通过编程方式进行设置和调整。

线程的优先级决定了它在与其他线程竞争CPU时间时的优先顺序。操作系统的调度算法通常会考虑线程的优先级来决定将CPU时间分配给哪个线程。高优先级线程相对于低优先级线程来说，有更高的概率获得CPU时间片，即有更多的机会去执行任务。然而，优先级并不是绝对的，只是一个相对的概念，高优先级线程并非一定比低优先级线程先执行。

下面通过一个简单的例子来解释优先级：

public class test1 implements Runnable {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " is running");
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(new test1());
        Thread thread2 = new Thread(new test1());

        thread1.setPriority(Thread.MIN_PRIORITY); // 设置线程1的优先级为最低
        thread2.setPriority(Thread.MAX_PRIORITY); // 设置线程2的优先级为最高

        thread1.start();
        thread2.start();
    }
}

在上述例子中，我们创建了两个线程 thread1 和 thread2，并将它们分别设置为最低优先级和最高优先级。在 run 方法中，每个线程会循环打印自己的名称。由于线程2的优先级更高，它具有更高的CPU时间片分配概率，因此它更有可能在竞争中先被调度执行。但是，该结果并不是绝对的，线程1仍然有机会在某些情况下先于线程2执行。

线程名

线程名用于为线程赋予一个可识别和标识的名称。每个线程都可以被命名，这样在调试和日志记录时就能更容易地识别和追踪线程的执行情况。线程名可以帮助我们区分不同的线程并理解它们在程序中的作用。
在Java中，可以通过setName方法为线程设置名字，也可以通过getName方法获取线程的名称。线程名通常是一个描述性的字符串，可以根据任务的特性和上下文进行命名，以便更好地反映线程的功能。

守护线程

守护线程（Daemon Thread）是指在程序运行过程中在后台默默执行的线程，它并不会阻止程序的退出。当所有非守护线程结束时，守护线程会自动终止。它们通常用于执行一些后台任务或提供一种服务性功能，而不需要干扰或阻塞主程序的正常执行。
守护线程的生命周期与程序的生命周期相伴而终。当所有非守护线程都结束时，守护线程会被自动停止，即使它们正在执行某些任务。为了标识一个线程为守护线程，可以使用线程对象的setDaemon(true)方法设置，这一方法必须在线程启动前调用。

中断线程

中断线程是指在多线程编程中，一个线程被要求停止执行或被强制终止。这通常是通过发送一个中断信号或设置一个标志来实现的，让线程在接收到中断请求后，安全地停止执行并释放资源。中断线程的目的通常是为了避免线程无法正常退出或处理某些异常情况。
下面是一个简单的Java示例，演示了如何中断一个线程：

public class InterruptExample {

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

        // 主线程等待一段时间后中断myThread
        try {
            Thread.sleep(2000); // 等待2秒钟
            myThread.interrupt(); // 发送中断信号
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程正在执行...");
                try {
                    Thread.sleep(1000); // 线程每隔1秒钟执行一次
                } catch (InterruptedException e) {
                    // 捕获到中断信号后，线程会退出循环
                    System.out.println("线程被中断，即将退出...");
                    Thread.currentThread().interrupt(); // 重新设置中断状态
                }
            }
        }
    }
}

在上述示例中，我们创建了一个线程（myThread），然后在主线程中等待2秒钟后发送中断信号给myThread。在MyRunnable线程中，线程不断地执行，但会检查是否接收到中断信号。如果接收到中断信号，线程会在捕获到InterruptedException后退出循环，完成线程的中断操作。
需要注意的是，中断线程并不会强制终止线程，而是通过设置一个中断标志，让线程在合适的时候自行终止。这样可以确保线程在终止时能够完成必要的清理工作，以避免资源泄漏和不一致的状态。

interrupted和isInterrupted,interrupted方法是一个静态方法，它检查当前线程是否被中断，并且会清除该线程的中断状态，isInterrupted是一个实例方法，用来检查是否有线程被中断。

未捕获异常的处理器

未捕获异常处理器（Uncaught Exception Handler）是在多线程或多线程应用程序中用来处理未捕获异常的一种机制。当一个线程抛出一个未捕获的异常时，如果该线程没有显式地捕获这个异常，那么异常会传递到线程的未捕获异常处理器中，这个处理器可以自定义，用于记录异常信息、执行特定的操作，或者进行应用程序的安全退出。
下面是一个简单的Java示例，演示了如何设置未捕获异常处理器：

public class UncaughtExceptionHandlerExample {

    public static void main(String[] args) {
        // 设置未捕获异常处理器
        Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler());

        // 创建一个线程并启动它，该线程会抛出一个未捕获异常
        Thread thread = new Thread(() -> {
            throw new RuntimeException("这是一个未捕获的异常");
        });
        thread.start();
    }

    static class CustomExceptionHandler implements Thread.UncaughtExceptionHandler {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            System.err.println("线程 " + t.getName() + " 抛出了未捕获的异常: " + e.getMessage());
            // 在这里可以添加自定义处理逻辑，如记录日志、发送通知等
        }
    }
}

在上述示例中，我们首先通过Thread.setDefaultUncaughtExceptionHandler方法设置了一个自定义的未捕获异常处理器（CustomExceptionHandler）。然后，创建了一个线程并启动它，该线程会故意抛出一个未捕获的异常。当这个异常抛出时，它会传递到我们设置的未捕获异常处理器中，CustomExceptionHandler中的uncaughtException方法将会执行，打印异常信息。您可以在这个方法中添加任何您需要的自定义处理逻辑，比如记录日志或发送通知。