Java中【线程】及【线程池】详细介绍（概念、实现方式、生命周期、案例）

线程

线程是计算机程序中的执行线索，它是程序中独立运行的最小单位。在操作系统中，每个进程都有自己的地址空间和资源，而线程是在进程中运行的，它共享进程的资源，包括内存、文件和网络连接等。
线程的使用可以提供以下优势：

1. 并发执行：线程可以同时执行多个任务，实现程序的并发处理，提高系统的响应速度。
2. 充分利用多核处理器：多核处理器可以同时执行多个线程，充分利用多核处理器的计算能力，提高程序的性能。
3. 支持异步编程：线程可以在后台执行任务，不影响主线程的执行，可以实现异步编程。
   

线程的生命周期

1. 新建状态（New）：当创建一个线程对象时，线程处于新建状态。此时系统已经为该线程分配了必要的资源，但还没有开始执行线程的代码。
2. 运行状态（Runnable）：当线程调用了 start() 方法后，线程进入运行状态。此时线程可以被调度并执行其 run() 方法中的代码。然而，线程可能会被操作系统暂停，以便执行其他线程，或者线程也可主动调用 yield() 方法让出 CPU 的使用权。
3. 阻塞状态（Blocked）：当线程处于阻塞状态时，它被暂停执行，直到获取到某个特定的条件。例如，线程可能被一个 synchronized 块锁定或等待其他线程的通知。一旦条件满足，线程将转移到就绪状态。
4. 等待状态（Waiting）：线程进入等待状态，以等待其他线程的特定操作。线程可以通过调用 wait() 方法、join() 方法或者 LockSupport.park() 方法进入等待状态。在等待状态下，线程不会消耗 CPU 资源，直到被其他线程唤醒。
5. 时间等待状态（Timed Waiting）：线程进入具有超时时间的等待状态，类似于等待状态。线程可以通过调用 sleep() 方法、wait(long timeout) 方法或者 LockSupport.parkNanos() 方法进入时间等待状态。
6. 终止状态（Terminated）：线程完成了它的全部工作，或者出现了异常导致线程终止。一旦线程终止，它就不能再回到任何其他状态。

在 Java 中，线程是通过 Thread 类来表示和管理的。创建线程的常见方法有两种：

1. 继承 Thread 类：创建一个继承自 Thread 类的子类，并重写 run() 方法来定义线程要执行的任务。然后通过实例化该子类并调用 start() 方法来启动线程。

class MyThread extends Thread {
    public void run() {
        // 定义线程要执行的任务
    }
}
MyThread myThread = new MyThread();
myThread.start();

2. 实现 Runnable 接口：创建一个实现了 Runnable 接口的类，并实现 run() 方法。然后通过实例化该类，并将其作为参数传递给 Thread 类的构造函数来创建线程。最后调用线程的 start() 方法来启动线程。

class MyRunnable implements Runnable {
    public void run() {
        // 定义线程要执行的任务
    }
}
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

除了以上基本的线程创建方法，Java 还提供了更高级的线程管理工具，如线程池（ThreadPoolExecutor）和并发工具类（如 CountDownLatch、CyclicBarrier、Semaphore 等），它们可以帮助开发者更方便地管理和控制线程的执行。
需要注意的是，在多线程编程中，要注意线程间的并发访问共享资源的问题，以避免数据竞争和死锁等并发问题。可以使用同步机制（如锁、信号量、条件变量等）来保证线程的互斥和同步

案例

如何使用线程来实现并发执行的计数器

public class CounterThread extends Thread {
    private int count;
    
    public CounterThread(int count) {
        this.count = count;
    }
    
    public void run() {
        for (int i = 1; i <= count; i++) {
            System.out.println("Thread " + Thread.currentThread().getId() + ": " + i);
            
            try {
                // 让线程休眠一段时间，模拟耗时的操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个案例中，我们定义了一个 CounterThread 类，它继承自 Thread 类并重写了 run() 方法。在 run() 方法中，我们使用一个循环来打印从1到指定的计数值的数字，并且每打印一个数字后休眠1秒钟，以模拟耗时的操作。
接下来，我们可以创建多个 CounterThread 类的实例，并通过调用 start() 方法来启动线程：

public class Main {
    public static void main(String[] args) {
        CounterThread thread1 = new CounterThread(5);
        CounterThread thread2 = new CounterThread(3);
        
        thread1.start();
        thread2.start();
    }
}
 

在这个示例中，我们创建了两个 CounterThread 实例，一个计数至5，另一个计数至3。然后，我们分别启动了这两个线程，它们会并发执行，各自独立地计数并打印数字。
通过这个线程案例，我们可以看到两个线程同时进行计数操作，并且它们可以在等待时间间隔内交替执行，实现了并发执行的效果。

线程池

线程池是一种用于管理和复用线程的机制，它可以提高线程的利用率和性能。线程池中包含一组线程，这些线程可以被重复使用来执行多个任务，而不需要每次执行任务时都创建和销毁线程。线程池在多线程编程的场景中非常常用，可以有效地控制并发线程的数量，提高程序的执行效率，并且避免线程创建和销毁的开销。
Java 提供了一个内置的线程池实现，即 ThreadPoolExecutor 类。它实现了 ExecutorService 接口，提供了一个灵活的线程池，可以通过设置不同的线程池参数来满足不同应用程序的需求。
线程池一般由以下几个主要组件组成：

1. 任务队列（Task Queue）：用于存储等待执行的任务。线程池中的线程会从任务队列中取出任务并执行。
2. 线程池管理器（Thread Pool Manager）：负责线程的创建、销毁和管理。它根据需要调整线程池中的线程数量，并将任务分配给空闲的线程进行执行。
3. 工作线程（Worker Threads）：实际执行任务的线程。线程池中的线程会循环地从任务队列中取出任务，并执行任务的代码逻辑。
4. 执行策略（Execution Policy）：决定了当任务队列已满时线程池如何处理新的任务。常见的策略有直接执行、抛弃、抛弃最旧任务等。

线程池的优点包括：

• 降低资源消耗：线程池可以避免频繁创建和销毁线程的开销，提高了线程的重用率，减少了系统资源的消耗。
• 提高响应速度：线程池中的线程可以立即处理可用的任务，避免了线程创建的延迟，提高了系统的响应速度。
• 控制并发线程数：通过设置线程池的大小，可以控制同时执行的线程数量，避免过多的线程导致系统资源耗尽或性能下降。
• 提供任务排队和拒绝策略：线程池可以提供任务队列，当任务数量超出线程池容量时，可以使用不同的拒绝策略进行处理。可以根据业务需求灵活地选择策略。

使用线程池时，我们只需要将需要执行的任务提交给线程池，线程池会自动管理线程，分配任务给空闲的线程执行。这样可以方便地控制线程的并发数，提高系统的性能和稳定性。

线程池参数

1. 核心线程数（Core Pool Size）：线程池中保持的常驻线程数量。即使线程处于空闲状态，核心线程也不会被销毁。
2. 最大线程数（Maximum Pool Size）：线程池允许的最大线程数量。当任务数量超过核心线程数且任务队列已满时，线程池会创建新的线程来处理任务，但最多不会超过最大线程数。
3. 线程存活时间（Keep Alive Time）：非核心线程在空闲状态下的存活时间。当线程在空闲时间超过设定的存活时间时，线程会被终止销毁，释放资源。
4. 时间单位（Time Unit）：线程存活时间的时间单位，例如秒、毫秒等。
5. 任务队列（Blocking Queue）：用于存储等待执行的任务的数据结构。常见的队列类型有有界队列（例如 ArrayBlockingQueue）和无界队列（例如 LinkedBlockingQueue）。
6. 线程工厂（Thread Factory）：用于创建线程的工厂类。通过自定义线程工厂，可以为线程池创建自定义、命名或设置特定属性的线程。
7. 拒绝策略（Rejected Execution Handler）：当任务无法被放入队列或执行时的处理策略。常见的策略有抛出异常、丢弃任务、丢弃最早的任务或执行调用者线程的任务。
   

线程池的生命周期

1. 创建线程池（Creation）：通过实例化线程池对象来创建线程池。可以使用线程池的构造方法或者使用线程池工厂类来创建。
2. 提交任务（Task Submission）：向线程池中提交任务，待执行。可以通过调用线程池的 execute() 方法或 submit() 方法来提交任务。
3. 执行任务（Task Execution）：线程池中的线程获取任务并执行。如果线程池中有空闲的线程，任务将立即执行。否则，任务将进入任务队列等待执行。线程池根据核心线程数、队列容量和最大线程数等参数来决定任务的执行和排队策略。
4. 关闭线程池（Shutdown）：当不再需要线程池时，需要显式地关闭线程池来释放资源。可以调用线程池的 shutdown() 方法来优雅地关闭线程池。
5. 终止执行（Termination）：线程池关闭后，所有已经提交的任务都会被执行完毕，然后线程池才会彻底终止。可以通过调用线程池的 awaitTermination() 方法来等待线程池的终止。

请注意，关闭线程池是一个重要的操作，在关闭之前需要确保所有任务都已经提交并执行完毕，否则可能会导致任务丢失或异常终止。
线程池的生命周期管理是保证多线程编程质量和性能的关键一环，合理地管理线程池的生命周期有助于避免资源泄漏和线程阻塞的问题，同时提高系统的性能和可维护性。

线程池的应用场景

1. 网络服务器：在网络服务器中，线程池可以用于并发地处理客户端请求。当有新的请求到达时，线程池中的线程可以立即处理请求，而无需每次都创建和销毁线程。这提高了处理请求的效率，同时也能控制并发线程的数量，避免资源耗尽。
2. 文件下载器：在文件下载器中，可以使用线程池来并行下载多个文件。每个下载任务可以分配给线程池中的一个线程进行处理，从而加快下载速度。线程池的大小可以根据网络状况和系统资源进行调整，以保持最佳的下载性能。
3. 批量数据处理：当有大量的数据需要处理时，可以使用线程池来并发执行处理任务。例如，数据分析任务、批量数据导入等场景，线程池可以有效地处理并行执行的任务，并提高整体的处理效率。
4. 定时任务调度：使用线程池来执行定时任务调度可以方便地管理和调度多个定时任务。线程池可以周期性地执行设定的任务，并提供灵活的调度策略，例如固定延迟、固定频率、一次性执行等。
5. 线程池异步回调：在异步编程中，可以使用线程池来执行耗时的操作，然后通过回调函数或者Futures模式获取操作的结果。这样可以避免主线程被阻塞，提高程序的响应能力。

这些案例展示了线程池在不同领域中的应用。线程池能够提供线程的重用、控制并发线程数量、管理任务调度等功能，以提高系统的性能、资源利用率和可维护性。在实际应用中，可以根据具体需求合理地配置线程池的参数，以达到最佳的效果。

案例

并发地计算一组数字的平方和

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建线程池，设置核心线程数为2
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // 创建一组数字
        int[] numbers = {1, 2, 3, 4, 5};
        
        // 提交任务给线程池，并计算平方和
        int sum = 0;
        for (int number : numbers) {
            SumSquaredTask task = new SumSquaredTask(number);
            executor.submit(task);
        }
        
        // 关闭线程池
        executor.shutdown();
        
        // 等待所有任务执行完毕
        while (!executor.isTerminated()) {
        
        }
        
        // 打印平方和结果
        System.out.println("平方和为: " + sum);
    }
    
    // 自定义任务类
    public static class SumSquaredTask implements Runnable {
        private int number;
        
        public SumSquaredTask(int number) {
            this.number = number;
        }
        
        @Override
        public void run() {
            int squared = number * number;
            addToSum(squared);
        }
        
        private synchronized void addToSum(int squared) {
            sum += squared;
        }
    }
}

在这个例子中，我们创建了一个固定大小为2的线程池，并使用ExecutorService接口的submit()方法向线程池提交任务。每个任务是一个SumSquaredTask对象，用于计算给定数字的平方并将其添加到sum变量中。最后，我们关闭线程池并等待所有任务执行完毕，然后打印平方和的结果。
这个简单的例子展示了如何使用线程池来并发执行任务，以提高计算效率和资源利用率。请注意，在实际应用中，我们需要根据具体需求和任务类型来调整线程池的参数，以获取最佳性能和可伸缩性。