【JavaEE】线程池和定时器

🔥个人主页： 中草药

🔥专栏：【Java】登神长阶 史诗般的Java成神之路

---

✏️一.线程池

在Java中，线程池（Thread Pool）是一种用于管理并发线程的机制，它提供了一种创建、复用和管理一组线程的方法，这些线程可以用来执行提交的任务。线程池的使用可以显著提高程序的性能和响应能力，尤其是在处理大量并发任务时。Java的java.util.concurrent包提供了丰富的API来创建和管理线程池，其中最核心的接口是ExecutorService，以及其实现类ThreadPoolExecutor。

创建

Java中线程池的创建主要通过Executors工厂类或直接使用ThreadPoolExecutor类来完成：

1. 使用Executors工厂类：

   • newSingleThreadExecutor()：创建一个单线程的线程池，它只会创建一个线程来执行任务。
   • newFixedThreadPool(int nThreads)：创建一个固定大小的线程池，线程数量由nThreads参数确定。
   • newCachedThreadPool()：创建一个可缓存的线程池，线程数量没有上限，当长时间没有新任务时，空闲线程会被终止。
   • newScheduledThreadPool(int corePoolSize)：创建一个可以安排任务的线程池，可以指定延迟执行任务或定期执行任务。

2. 使用ThreadPoolExecutor类：

• ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)：这是一个构造函数，可以自定义线程池的核心参数，如核心线程数、最大线程数、线程空闲时间、工作队列等。

使用

1. 提交任务 ：使用execute(Runnable command)或submit(Callable<T> task)方法提交任务到线程池。
2. 关闭线程池 ：使用shutdown()方法关闭线程池，等待所有已提交的任务完成；使用shutdownNow()方法立即关闭线程池并尝试取消正在执行的任务。

举例

• 使用Executors.newFixedThreadPool (5) 能创建出固定包含10个线程的线程池
• 返回值类型为ExecutorService
• 通过ExecutorService.submit可以注册一个任务到线程池中

public static void main(String[] args) throws InterruptedException {
        ExecutorService service= Executors.newFixedThreadPool(5);
        for (int i = 0; i < 100; i++) {
            int id=i;
            service.submit(()->{
                System.out.println("执行任务"+id+";"+Thread.currentThread().getName());
            });
        }
        // 最好不要立即就终止, 可能使任务还没执行完呢, 线程就被终止了.
        Thread.sleep(2000);

        // 关闭线程池
        service.shutdown();
        System.out.println("程序退出");
    }

线程池配置参数分析*

ThreadPoolExecutor 提供了更多的可选参数, 可以进⼀步细化线程池⾏为的设定

1. 核心线程数-CorePoolSize

   • 参数名：corePoolSize
   • 描述：线程池中保持的线程的最少数量。即使线程池中没有任务需要执行，只要线程的数量不超过corePoolSize，线程池就不会销毁线程。这样可以保证线程池随时准备接收新的任务，而不需要频繁地创建和销毁线程。

2. 最大线程数-MaximumPoolSize

   • 参数名：maximumPoolSize
   • 描述：线程池中允许的最大线程数量。当线程池中的活动线程数量达到maximumPoolSize后，线程池不会创建新的线程，而是将任务放入工作队列中等待执行。如果工作队列已满，线程池会采取拒绝策略处理新任务。

3. 空闲线程存活时间-KeepAliveTime

   • 参数名：keepAliveTime
   • 描述：当线程池中的线程数量超过corePoolSize时，超出的线程会在没有任务可执行时等待的时间长度。如果在keepAliveTime时间内没有新任务到来，超出的线程将被终止。这有助于控制线程池的规模，避免在任务量减少时线程资源的浪费。

4. 时间单位-Unit

   • 参数名：unit
   • 描述：配合keepAliveTime使用，指定空闲线程存活时间的单位，如毫秒、秒、分钟等。

5. 工作队列-WorkQueue

   • 参数名：workQueue
   • 描述：用于存放等待执行的任务的阻塞队列。当线程池中的线程数量达到corePoolSize且所有线程都在执行任务时，后续到达的任务会被放置在工作队列中等待执行。常见的队列类型有ArrayBlockingQueue（有界队列）、LinkedBlockingQueue（有界或无界队列）、SynchronousQueue（不存储元素的队列）等。

6. 拒绝策略-RejectedExecutionHandler

   • 参数名：handler
   • 描述：当线程池无法接受新任务时（即线程数量达到maximumPoolSize且工作队列已满）所采取的策略。

常见的拒绝策略

• AbortPolicy：抛出RejectedExecutionException异常。
• CallerRunsPolicy：由调用者线程执行该任务，即直接在调用execute方法的线程中执行任务。
• DiscardPolicy：静默丢弃无法处理的任务。
• DiscardOldestPolicy：丢弃队列中最老的任务，并尝试再次提交新任务。

模拟实现

• 核心操作为submit，将任务加入线程池
• 使用Runnable描述一个任务
• 使用一个BlockingQueue组织所有任务
• 不停从BlockingQueue中取任务并执行

class MyThreadPool{
    private BlockingQueue<Runnable> queue=new ArrayBlockingQueue<>( 1000);

    public MyThreadPool(int n){//此处的n表示可以创建几个线程
        for (int i = 0; i < n; i++) {
            Thread t=new Thread(()->{
                while(true){
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            t.start();
        }
    }

    /**
     * 添加任务
     * @param runnable
     */
    public void submit(Runnable runnable){
        try{
            queue.put(runnable);
        }catch (InterruptedException e){
            throw new RuntimeException(e);
        }
    }
}

测试代码

public static void main(String[] args) {
        MyThreadPool pool=new MyThreadPool(5);
        for (int i = 0; i < 100; i++) {
            int id=i;
            pool.submit(()->{
                System.out.println("执行任务"+id+";"+Thread.currentThread().getName());
            });
        }
    }

测试结果

✒️二.定时器

在Java中，定时器（Timer）是一个重要的工具，用于执行定时任务，无论是单次的还是周期性的，类似于一个闹钟，到达一个设定的时间之后就会执行某个指定好的代码Java提供了多种方式来实现定时任务。

基本使用

其中最常用的是java.util.Timer类和java.util.concurrent.ScheduledExecutorService接口。下面将详细介绍这两种实现方式。

java.util.Timer 类

java.util.Timer 是一个简单的定时器类，它使用一个单独的守护线程来调度和执行任务。它通常与java.util.TimerTask一起使用，后者是java.util.Timer类的任务执行单元。

public static void main(String[] args) {
        Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello 3");
            }
        },3000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello 2");
            }
        },2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello 1");
            }
        },1000);
    }

注意事项

• 在使用定时器时，一定要处理好任务执行中可能出现的异常，否则守护线程可能因为异常而终止，导致定时器失效。
• 确保在应用程序结束前正确地关闭定时器，避免线程泄露和资源浪费。
• 考虑到线程安全和并发控制，ScheduledExecutorService在大多数情况下是更好的选择，尤其是当任务需要并发执行时。

模拟实现

package demo;

import java.util.PriorityQueue;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 模拟实现定时器
 */
class MyTimerTask implements Comparable<MyTimerTask> {
    private Runnable runnable;
    private long time;
    //此处的time是毫秒时间戳，表示这个任务具体啥时候执行

    public MyTimerTask (Runnable runnable,long delay){
        this.runnable=runnable;
        this.time=System.currentTimeMillis()+delay;
    }

    public void run(){
        runnable.run();
    }

    public long getTime(){
        return time;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        // 此处这里的 - 的顺序, 就决定了这里是大堆还是小堆.
        // 此处需要小堆.
        return (int)(this.time-o.time);
    }
}

class MyTimer{
    private PriorityQueue<MyTimerTask> queue=new PriorityQueue<>();
    //如果用List不是最好的选择，在后续执行列表中任务时，需要依次遍历每个元素
    private Object locker=new Object();

    //创建线程，负责执行上述队列中的内容
    public MyTimer(){
        Thread t=new Thread(()->{
           try{
               while(true){
                   synchronized(locker){
                       while(queue.isEmpty()){
                           locker.wait();
                       }
                       MyTimerTask current=queue.peek();
                       if (System.currentTimeMillis()>=current.getTime()){
                           //执行该任务
                           current.run();
                           //将执行过的任务从队列中删除
                           queue.poll();
                       }else{
                           //暂且不执行
                           locker.wait(current.getTime()-System.currentTimeMillis());
                       }
                   }
               }
           }catch (InterruptedException e){
               throw new RuntimeException(e);
           }
        });
        t.start();
    }

    public void schedule(Runnable runnable,long delay){
        synchronized(locker){
            MyTimerTask current=new MyTimerTask(runnable,delay);
            queue.offer(current);
            locker.notify();
        }
    }


}

测试代码

public static void main(String[] args) {
        MyTimer timer=new MyTimer();

        timer.schedule(()->{
            System.out.println("倒计时 2");
        },2000);

        timer.schedule(()->{
            System.out.println("倒计时 1");
        },3000);

        timer.schedule(()->{
            System.out.println("倒计时 3");
        },1000);
        //证明优先级队列的作用
    }

结果

🖋️三.总结与反思

在深入研究Java并发编程的过程中，线程池和定时器是两个不可或缺的概念。它们不仅体现了Java在处理并发和定时任务上的强大功能，也反映了现代软件工程中资源管理和效率优化的重要性。以下是我在学习这两个主题后的总结与反思。

线程池：高效资源管理的艺术

线程池，顾名思义，是一个预先创建好的线程集合，用于执行提交的任务。它通过复用现有线程，避免了线程创建和销毁的开销，从而提高了系统的响应速度和资源利用率。线程池的配置参数，如核心线程数、最大线程数、工作队列类型等，需要根据具体的应用场景和系统资源进行细致调整。合理配置的线程池能够显著提升并发任务的处理能力，减少资源浪费，是高性能服务器应用的基石。

在实际应用中，我深刻体会到线程池的配置需要平衡并发度与系统负载。过多的线程可能导致系统资源紧张，而过少的线程则可能无法充分利用系统资源。此外，线程池的管理，如任务的排队策略、异常处理、线程的生命周期管理等，也是实现高效、健壮系统的关键。

定时器：精准时间控制的利器

定时器则是在Java中执行定时任务的重要工具。无论是简单的java.util.Timer，还是更强大的java.util.concurrent.ScheduledExecutorService，它们都提供了执行周期性或一次性定时任务的能力。定时器的使用极大地丰富了Java在事件驱动、任务调度等方面的功能，是实现自动化运维、数据定时处理等场景的基础。

在使用定时器时，我注意到几个关键点：首先，选择合适的定时器类型至关重要。Timer简单易用，但ScheduledExecutorService提供了更高级的调度策略和更好的并发支持。其次，定时任务的异常处理不容忽视，否则可能导致任务执行失败而不被察觉。最后，正确关闭定时器，避免线程泄露，是编写健壮程序的必要步骤。

反思

通过学习和实践线程池与定时器，我深刻理解到并发编程的复杂性和魅力。在设计系统时，不仅要考虑功能的实现，还要兼顾性能、资源管理和错误处理。线程池和定时器的合理应用，能够显著提升软件的响应速度和稳定性，但同时也对程序员提出了更高的要求。

面向未来，随着云计算和分布式系统的普及，线程池和定时器的概念将更加重要。如何在分布式环境中高效、安全地管理线程和执行定时任务，将成为新一代软件工程师面临的新挑战。掌握线程池和定时器的原理及最佳实践，无疑将为迎接这些挑战打下坚实的基础。

总之，Java中的线程池和定时器不仅是编程技巧的体现，更是现代软件工程思想的反映。通过深入学习和不断实践，我期待能够将这些知识应用于更复杂的系统设计和开发中，创造出既高效又可靠的软件产品。

🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

以上，就是本期的全部内容啦，若有错误疏忽希望各位大佬及时指出💐

制作不易，希望能对各位提供微小的帮助，可否留下你免费的赞呢🌸