详解线程和线程池

线程（Thread）是操作系统能够进行运算调度的最小单位，它代表了进程中的一条执行路径，是进程内的一个独立执行流。线程作为进程中的一部分，拥有自己的程序计数器（PC，即当前指令指针）、寄存器集合以及调用栈，这些允许线程保持其执行上下文并能够在进程的地址空间内独立执行任务。

线程的特点包括：

1. 资源共享：同一进程中的多个线程共享该进程的全部系统资源，例如内存空间（包括代码段、数据段、堆和打开的文件描述符等）。
2. 独立调度：线程是可以被操作系统独立调度和分派的基本单位，即每个线程都可以被分配到CPU核心上执行。
3. 并发执行：一个进程内的多个线程可以并发地执行不同的任务，提高系统的并发性能，特别是在多核或多处理器系统中。
4. 独立状态：尽管线程共享大部分资源，但它们有自己的线程本地存储（Thread-Local Storage, TLS）以及其他与执行相关的信息，如优先级、线程私有数据（如栈信息）等。
5. 状态转换：线程有多种状态，如就绪态（等待CPU时间片）、运行态（正在执行）、阻塞态（因等待某一事件而暂停执行）等。

通过创建和管理多个线程，应用程序可以更好地利用系统资源，实现高效的并发处理，并且在线程间的通信和同步机制的帮助下，协调不同线程间的合作和数据交换。

在Java中线程有三种实现方式：

1. 继承 Thread 类

   • 创建一个新的类，让它继承自 java.lang.Thread 类。
   • 重写 Thread 类中的 run() 方法，定义线程需要执行的任务。
   • 创建这个自定义线程类的实例，并调用 start() 方法启动线程。

     public class MyThread extends Thread {
         @Override
         public void run() {
             // 在这里定义线程要执行的任务
             System.out.println("执行自定义线程类中的run()方法");
         }
     
         public static void main(String[] args) {
             MyThread thread = new MyThread();
             thread.start(); // 启动线程
         }
     }

2. 实现 Runnable 接口

   • 创建一个新的类，实现 java.lang.Runnable 接口。
   • 在这个类中实现 run() 方法，同样定义线程需要执行的任务。
   • 将这个 Runnable 对象传给 Thread 类的构造器，创建一个 Thread 实例，然后调用其 start() 方法启动线程。

     public class RunnableExample implements Runnable {
         @Override
         public void run() {
             // 在这里定义线程要执行的任务
             System.out.println("执行Runnable接口实现类中的run()方法");
         }
     
         public static void main(String[] args) {
             RunnableExample task = new RunnableExample();
             Thread thread = new Thread(task);
             thread.start(); // 启动线程
         }
     }

3. 实现 Callable 接口（配合 FutureTask 或 ExecutorService）

   • 自定义类实现 java.util.concurrent.Callable<V> 接口，这里的 <V> 是线程计算结果的类型。
   • 实现 call() 方法，该方法可以有返回值并且可以抛出受检查的异常。
   • 使用 FutureTask 封装 Callable 对象，并将其转换为可执行的线程任务，或者提交到 ExecutorService 中执行。
   • 可以通过 Future 对象来获取 Callable 线程执行完成后的结果。

     import java.util.concurrent.Callable;
     import java.util.concurrent.FutureTask;
     
     public class CallableExample implements Callable<String> {
         @Override
         public String call() throws Exception {
             // 在这里定义线程要执行的任务，并返回一个结果
             System.out.println("执行Callable接口实现类中的call()方法");
             return "Callable Result";
         }
     
         public static void main(String[] args) throws ExecutionException, InterruptedException {
             CallableExample callableTask = new CallableExample();
             FutureTask<String> futureTask = new FutureTask<>(callableTask);
             Thread thread = new Thread(futureTask);
             thread.start();
     
             // 获取线程执行的结果（如果需要的话，可以通过get方法同步等待结果）
             String result = futureTask.get();
             System.out.println("Callable的结果: " + result);
         }
     }

start和run方法的区别

1. start() 方法：

   • start() 是 java.lang.Thread 类的一个方法，用于启动一个新的线程。
   • 当调用一个线程对象的 start() 方法时，Java虚拟机会为此线程创建一个新的执行线程，然后由JVM负责调度该线程与其他线程一起并发执行。
   • 调用 start() 方法后，线程将处于就绪状态（READY），等待CPU时间片，一旦得到调度，线程将会在其自身的上下文中调用 run() 方法。
   • 重要的是，每个线程对象只能调用一次 start() 方法，多次调用会导致 IllegalThreadStateException 异常。

2. run() 方法：

   • run() 是 java.lang.Thread 类或者 Runnable 接口中定义的一个抽象方法，它包含了线程需要执行的任务代码。
   • 如果直接调用某个线程对象的 run() 方法，那么这段代码将在当前线程（通常是主线程）中顺序执行，而不是在新的线程中执行，这就失去了并发的意义。
   • 因此，为了让 run() 方法中的代码在新的线程中并发执行，必须先通过 start() 方法启动新线程。

总结起来，start() 方法是启动新线程的关键步骤，它会创建并启动一个新的线程，使线程从就绪状态开始，进而执行 run() 方法中的代码；而 run() 方法本身不创建新线程，仅包含线程要执行的具体逻辑。

线程的生命周期

1. 新建（New）状态：

   • 当通过 new 关键字创建一个线程对象后，线程就处于新建状态。此时线程对象已经存在，但是还没有调用 start() 方法，因此操作系统级别的线程尚未创建。

2. 就绪（Runnable）状态：

   • 当调用线程对象的 start() 方法后，Java虚拟机（JVM）会为其创建操作系统级别的线程，此时线程进入就绪状态。
   • 在就绪状态下，线程具备了执行条件，等待被CPU调度执行。操作系统根据线程调度策略选择一个线程进行CPU时间片分配，被选中的线程就从就绪状态变为运行状态。

3. 运行（Running）状态：

   • 运行状态的线程获得了CPU的时间片，正在执行其 run() 方法里的代码。
   • 多核CPU环境下，可能有多个线程同时处于运行状态。

4. 阻塞（Blocked/Sleeping/Waiting/Timed Waiting）状态：

   • 当线程由于某种原因不能继续执行时，会从运行状态转为阻塞状态。
   • 阻塞状态包括：
     • 等待状态（Waiting）：调用 wait() 方法，线程等待其他线程的通知（通过 notify() 或 notifyAll() 方法）才能重新进入就绪状态。
     • 无限期睡眠状态（Sleeping）：调用 sleep(long millis) 不带超时参数时，线程会在指定时间内让出CPU并停止执行。
     • 定时等待状态（Timed Waiting）：调用 sleep(long millis) 带有超时参数或 wait(long timeout)、join(long millis)、LockSupport.parkNanos() 等方法时，线程会在指定时间过后重新变为就绪状态。
     • 阻塞状态（Blocked）：当线程试图获取一个锁（如 synchronized 关键字或显式锁）而该锁不可用时，线程会被阻塞，直到锁变得可用。

5. 终止（Terminated/Dead）状态：

   • 线程执行完 run() 方法或提前通过 interrupt() 方法中断后，线程就会结束其生命周期，进入终止状态。
   • 终止状态的线程不能再被重新启动，而且线程相关的所有资源都会被回收。

线程在生命周期内可能会在这几种状态之间互相转换，这种转换是由Java虚拟机以及操作系统线程调度机制控制的。理解线程的生命周期状态及转换对于调试多线程程序和优化并发性能非常关键。

线程池

Java线程池的主要参数包括以下7个：

1. corePoolSize： 核心线程数，线程池中的基本线程数。即使在没有任务执行的情况下，线程池也会维持至少这么多的核心线程不被销毁。当有新的任务提交时，线程池首先尝试创建和启动足够的线程来处理任务，直至达到corePoolSize。

2. maximumPoolSize： 最大线程数，线程池所能容纳同时执行的最大线程数。当线程池中的线程数已经达到corePoolSize，并且workQueue（任务队列）已满，这时才会创建新的线程，直到总线程数达到maximumPoolSize。

3. keepAliveTime： 空闲线程存活时间，非核心线程在闲置一段时间（无任务执行）后，如果没有新的任务到来，则会被销毁，这个时间就是keepAliveTime。只有当线程池的线程数超过corePoolSize时，才会启用这一策略。

4. unit： keepAliveTime的时间单位，可以是纳秒（NANOSECONDS）、微秒（MICROSECONDS）、毫秒（MILLISECONDS）、秒（SECONDS）等。

5. workQueue： 工作队列，这是一个BlockingQueue接口的实现，用于保存待处理的任务。当线程池中的线程数目达到corePoolSize后，新提交的任务将被存储在这个队列中等待执行。

6. threadFactory： 线程工厂，用于创建新的线程。当线程池需要增加线程时，会调用threadFactory创建新线程。默认的线程工厂会创建同一线程组的非守护线程，用户可以自定义线程工厂来设置线程名称、优先级等属性。

7. handler： 拒绝策略，当线程池和工作队列均无法接受新任务时（即线程池中的线程数已经达到maximumPoolSize，并且workQueue已满），将采取的一种拒绝策略。Java提供了以下四种预设的拒绝策略：

   • AbortPolicy：默认策略，直接抛出RejectedExecutionException异常。
   • CallerRunsPolicy：调用者所在线程来运行任务。
   • DiscardPolicy：默默地丢弃掉任务，不予任何处理。
   • DiscardOldestPolicy：丢弃最旧的未处理任务，然后尝试重新提交当前任务。

创建线程池时，可以根据实际应用场景合理配置这些参数，以达到最优的资源利用率和系统性能。

线程池的执行流程

1. 创建线程池：

   • 通过 ThreadPoolExecutor 构造函数创建线程池实例，或者通过 Executors 类的静态工厂方法创建预设配置的线程池。

2. 提交任务：

   • 使用 execute(Runnable command) 或 submit(Callable<T> task) 方法将任务提交到线程池中。execute() 用于执行没有返回值的任务，而 submit() 则可用于执行有返回值的任务，并返回一个 Future 对象，用于获取任务执行结果。

3. 任务调度：

   • 当任务提交时，线程池首先检查当前活跃线程数是否少于核心线程数（corePoolSize）。如果是，则创建一个新的核心线程来执行任务。
   • 若当前活跃线程数已达到核心线程数，任务会被尝试添加到工作队列（BlockingQueue）中等待执行。
   • 如果工作队列已满，且当前线程数仍低于最大线程数（maximumPoolSize），则创建一个非核心线程来执行任务。
   • 如果工作队列已满，且当前线程数已达到最大线程数，则触发拒绝策略（RejectedExecutionHandler），比如默认情况下抛出 RejectedExecutionException。

4. 线程管理：

   • 当线程执行完一个任务后，会尝试从工作队列中取出下一个任务继续执行，如果队列为空，则线程会等待队列中有新的任务加入。
   • 非核心线程在空闲一段时间（由 keepAliveTime 参数设定）后，如果此时线程池中线程数超过了核心线程数，那么超出的线程将会被终止，以释放系统资源。
   • 当线程池关闭后，不再接受新的任务，但它会等待现有任务执行完成后再彻底关闭。

5. 线程池状态变更：

   • 在整个过程中，线程池的状态会根据提交的任务和线程池的操作发生变化，包括RUNNING（运行）、SHUTDOWN（关闭，不再接受新任务）、STOP（停止，尝试停止活动任务）和TERMINATED（终止，所有任务已完成，线程池完全关闭）。

总的来说，线程池旨在通过有效地管理线程生命周期和任务排队机制，减少频繁创建和销毁线程的开销，并通过合理的参数配置和策略调整，确保系统在高并发场景下既能高效利用资源，又能避免过度消耗系统资源导致的问题。