Java并发编程-线程池(01)

自定义线程池与拒绝策略
最新推荐文章于 2025-11-25 12:11:25 发布
原创 最新推荐文章于 2025-11-25 12:11:25 发布 · 1.8k 阅读 · 49 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #intellij-idea

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、线程池

1.1 池化（Pooling）

池化（Pooling）思想是一种常见的软件设计模式，主要目的是在程序运行过程中预先创建和维护一组可重用的资源对象（如线程（Thread）、数据库连接（Connection）等），以便在需要时能够快速获取，而不是每次需要时都动态创建新的对象。这种做法的核心在于，通过重复利用已经创建的对象，可以避免频繁的创建和销毁操作，从而提升系统的性能、资源利用率和响应速度。
在这里插入图片描述

1.2 为什么需要线程池

在Java中，创建一个线程需要执行new Thread()先获得一个线程对象，然后调用start()方法使得线程开始运行。对于在高并发场景下，如果频繁地创建对象，容易出现OOM（Out Of Memory）错误，并且，如果创建的线程数过多，频繁地进行线程上下文切换也会影响到程序性能。

在Java中使用线程池的主要目的是有效地管理和重用线程，从而提高应用程序的性能和资源利用率。具体来说，使用线程池有以下几个重要的原因：
1.减少资源消耗：创建和销毁线程是一项昂贵的操作，涉及到操作系统的资源分配和内存管理。如果频繁地创建和销毁线程，会消耗大量的系统资源，降低系统的性能。
2.提高响应速度：当任务到达时，线程池中的线程可以立即开始执行，而不需要等待新线程的创建。
3.提高系统稳定性：线程池能够限制并发线程的数量，防止系统因为过度并发而崩溃，提高了系统的稳定性。
4.方便管理线程：线程池提供了统一的接口和管理机制，可以方便地对线程进行监控、统计、调优等操作。

二、自定义线程池

我们可以简单地模拟手写一个基础的线程池实现。基本设计如下图所示：
在这里插入图片描述
其中，线程池从任务队列中取出任务Task交给内部维护的线程Thread来处理，扮演的是“消费者”的角色；任务队列用于存放需要被调度执行的任务，扮演的是“消费品”角色；main线程用于产生任务并将任务存放到任务队列中，扮演的是“生产者”的角色。

2.1 任务队列 - TaskBlockingQueue

任务队列是一个阻塞队列，其实现如下所示：

public class TaskBlockingQueue<T> {
    /**
     * 任务队列：存放任务集合
     */
    private Deque<T> queue = new ArrayDeque<>();
    /**
     * 同步线程之间获取资源
     */
    private ReentrantLock lock = new ReentrantLock();
    /**
     * 生产者条件变量 => 满等待：任务队列queue已满，暂停新增任务
     */
    private Condition fullWaitSet = lock.newCondition();
    /**
     * 消费者条件变量 => 空等待：任务队列queue为空，暂停消费任务
     */
    private Condition emptyWaitSet = lock.newCondition();
    /**
     * 队列容量大小
     */
    private int capacity;

    public TaskBlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 阻塞取出任务
     *
     * @return
     */
    public T take() {
        lock.lock();
        try {
            //当前任务资源为空 -> 暂停消费
            while (queue.isEmpty()) {
                //消费者等待
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //取出任务消费 --> 头部取出
            T task = queue.removeFirst();
            //唤醒满等待线程
            fullWaitSet.signal();
            return task;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 阻塞添加任务
     * @param task
     */
    public void put(T task) {
        lock.lock();
        try {
            //任务队列满 -- 生产者暂停添加任务
            while (queue.size() == this.capacity) {
                try {
                	//无时限等待
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //可以添加任务 -- 尾部添加
            queue.addLast(task);
            //唤醒空等待线程
            emptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }

}

2.2 线程池 - MyThreadPool

自定义线程池类实现如下：

public class MyThreadPool {
    /**
     * 任务队列
     */
    private TaskBlockingQueue<Runnable> taskQueue;
    /**
     * 核心线程数
     */
    private int coreSize;
    /**
     * 执行任务的线程集合
     */
    private HashSet<Worker> workers = new HashSet<>();

    /**
     * 工作线程
     */
    class Worker extends Thread {
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //任务不为空时 -- 执行任务
            while (null != task || (task = taskQueue.take()) != null) {
                try {
                    log.debug("执行任务: {}", task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            //循环结束-任务执行完毕，移除worker线程
            synchronized (this) {
                log.debug("移除worker: {}", this);
                workers.remove(this);
            }
        }
    }

    public MyThreadPool(int taskQueueSize, int coreSize) {
        this.coreSize = coreSize;
        this.taskQueue = new TaskBlockingQueue<>(taskQueueSize);
    }

    /**
     * 线程池执行任务
     * @param task
     */
    public void execute(Runnable task) {
       synchronized (workers) {
           //直接交给Worker线程执行
           if (workers.size() < coreSize) {
               Worker worker = new Worker(task);
               log.debug("创建Worker: {}, 任务: {}", worker, task);
               workers.add(worker);
               worker.start();
           }
           //加入阻塞队列暂存
           else {
               log.debug("新增等待任务: {}", task);
               taskQueue.put(task);
           }
       }
    }

}

2.3 测试自定义线程池

2.3.1 死等情况

假设自定义线程池的核心线程数为2，任务队列容量为10，编写测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10, 2);
        for (int i = 0; i < 5; i++) {
            int j = i;
            pool.execute(() -> {
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

查看执行结果如下：
在这里插入图片描述
分析可知，工作的两个线程分别为Thread-0、Thread-1。初始时，工作线程数小于核心线程数，Thread-0、Thread-1得到创建并开始执行任务fcb0、3e64（用打印结果的最后4位来代指任务），在Thread-0、Thread-1工作期间，新增的任务37bc、a09c、0994暂时没有空闲的线程来执行，需要放入到任务队列中。当Thread-0、Thread-1执行完任务fcb0、3e64后变为空闲状态，然后从任务阻塞队列（按照加入顺序）读取任务37bc、a09c并执行，执行完毕后Thread-0、Thread-1又变回空闲线程，然后Thread-0取出任务0994执行，Thread-1为空闲且保持运行状态。Thread-0执行完任务0994后，同样处于空闲且保持运行状态。

在整个过程中，只创建了2个（核心线程数）个工作线程用于工作和复用，但从最后结果来看，当任务队列为空即工作线程已经没有任务要执行时，却依旧处于运行状态以等待下一个任务，故需要加上一个超时时间设置来避免工作线程死等的情况。

2.3.2 超时时间设置

对任务阻塞队列的take()方法做增加超时时间设置的改造，如下所示：

/**
     * 阻塞取出任务 -- 设置超时时间
     *
     * @return
     */
    public T poll(long timeout, TimeUnit timeUnit) {
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            //当前任务资源为空 -> 暂停消费
            while (queue.isEmpty()) {
                //消费者等待
                try {
                    //超时时间到
                    if (nanos <= 0) {
                        return null;
                    }

                    //剩余时间
                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //取出任务消费 --> 头部取出
            T task = queue.removeFirst();
            //唤醒满等待线程
            fullWaitSet.signal();
            return task;
        } finally {
            lock.unlock();
        }
    }

同样，线程池实现也做一个对应改造：

public class MyThreadPool {
    /**
     * 任务队列
     */
    private TaskBlockingQueue<Runnable> taskQueue;
    /**
     * 核心线程数
     */
    private int coreSize;
    /**
     * 执行任务的线程集合
     */
    private HashSet<Worker> workers = new HashSet<>();
    /**
     * 时间单位
     */
    private TimeUnit timeUnit;
    /**
     * 超时时间
     */
    private long timeout;

    /**
     * 工作线程
     */
    class Worker extends Thread {
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //任务不为空时 -- 执行任务
            while (null != task || (task = taskQueue.poll(timeout, timeUnit)) != null) {
                try {
                    log.debug("执行任务: {}", task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            //循环结束，移除worker线程
            synchronized (this) {
                log.debug("移除worker: {}", this);
                workers.remove(this);
            }
        }
    }

    public MyThreadPool(int taskQueueSize, int coreSize, TimeUnit timeUnit, long timeout) {
        this.coreSize = coreSize;
        this.taskQueue = new TaskBlockingQueue<>(taskQueueSize);
        this.timeUnit = timeUnit;
        this.timeout = timeout;
    }

    /**
     * 线程池执行任务
     * @param task
     */
    public void execute(Runnable task) {
       synchronized (workers) {
           //直接交给Worker线程执行
           if (workers.size() < coreSize) {
               Worker worker = new Worker(task);
               log.debug("创建Worker: {}, 任务: {}", worker, task);
               workers.add(worker);
               worker.start();
           }
           //加入阻塞队列暂存
           else {
               log.debug("新增等待任务: {}", task);
               taskQueue.put(task);
           }
       }
    }

}

假设线程池的超时时间设置为2秒，编写测试类如下，

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10, 2, TimeUnit.SECONDS, 2);
        for (int i = 0; i < 5; i++) {
            int j = i;
            pool.execute(() -> log.debug("===> {} ", j + 1));
        }
    }
}

运行结果如下所示：
在这里插入图片描述
可以看到，超时时间到了以后，工作线程被移除，整个程序运行结束，工作线程不再是无限死等。

2.3.3 任务队列满

现假设需要执行的任务数暴增，从5个变为15个，已知任务队列的大小为10。编写测试类如下：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10, 2, TimeUnit.SECONDS, 2);
        for (int i = 0; i < 15; i++) {
            int j = i;
            pool.execute(() -> log.debug("===> {} ", j + 1));
        }
    }
}

运行结果如下：
在这里插入图片描述
向任务队列添加任务时都是阻塞式地添加，在任务数量过多的情况下，如果主线程需要执行过多的添加任务操作，那么就会对主线程的性能造成严重影响，所以对于核心工作线程无空闲的且阻塞任务队列又已满的情况，应该让主线程可以选择性地执行一些拒绝策略。

三、 自定义拒绝策略

3.1 带超时添加任务

改造任务阻塞队列的添加任务方法put，新增超时时间判断处理，如下所示：

 /**
     * 阻塞添加任务 -- 新增超时时间设置
     * @param task
     */
    public boolean offer(T task, long timeout, TimeUnit unit) {
        lock.lock();
        try {
            long nanos = unit.toNanos(timeout);
            //任务队列满 -- 生产者暂停添加任务
            while (queue.size() == this.capacity) {
                log.debug("等待加入任务队列: {}", task);
                if (nanos <= 0) {
                    return false;
                }

                try {
                    nanos = fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //可以添加任务 -- 尾部添加
            log.debug("加入任务队列: {}", task);
            queue.addLast(task);
            //唤醒空等待线程
            emptyWaitSet.signal();
            return true;
        } finally {
            lock.unlock();
        }
    }

3.2 拒绝方法

为方便灵活设置拒绝策略，可将拒绝策略定义为一个函数式接口，如下所示：

@FunctionalInterface
public interface MyRejectPolicy<T> {

    /**
     * 拒绝策略设置
     * @param taskQueue
     * @param task
     */
    void reject(TaskBlockingQueue<T> taskQueue, T task);
    
}

改造任务阻塞队列，新增拒绝方法如下所示:

/**
     * 尝试向任务队列新增任务
     * @param rejectPolicy
     * @param task
     */
    public void tryPut(MyRejectPolicy<T> rejectPolicy, T task) {
        lock.lock();
        try {
            //队列已满 ==> 执行拒绝策略
            if (queue.size() == capacity) {
	            log.debug("队列已满,执行拒绝策略...");
                rejectPolicy.reject(this, task);
            } else {
                //队列还有空闲
                log.debug("加入任务队列: {}", task);
                queue.addLast(task);
                //唤醒空等待
                emptyWaitSet.signal();
            }
        } finally {
            lock.unlock();
        }
    }

自定义线程池实现类改造如下：

public class MyThreadPool {
    /**
     * 任务队列
     */
    private TaskBlockingQueue<Runnable> taskQueue;
    /**
     * 拒绝策略
     */
    private MyRejectPolicy<Runnable> rejectPolicy;
    /**
     * 核心线程数
     */
    private int coreSize;
    /**
     * 执行任务的线程集合
     */
    private HashSet<Worker> workers = new HashSet<>();
    /**
     * 时间单位
     */
    private TimeUnit timeUnit;
    /**
     * 超时时间
     */
    private long timeout;

    /**
     * 工作线程
     */
    class Worker extends Thread {
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //任务不为空时 -- 执行任务
            while (null != task || (task = taskQueue.poll(timeout, timeUnit)) != null) {
                try {
                    log.debug("执行任务: {}", task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            //循环结束，移除worker线程
            synchronized (this) {
                log.debug("移除worker: {}", this);
                workers.remove(this);
            }
        }
    }

    public MyThreadPool(int taskQueueSize, int coreSize, TimeUnit timeUnit, long timeout,
                        MyRejectPolicy<Runnable> rejectPolicy) {
        this.coreSize = coreSize;
        this.taskQueue = new TaskBlockingQueue<>(taskQueueSize);
        this.timeUnit = timeUnit;
        this.timeout = timeout;
        this.rejectPolicy = rejectPolicy;
    }

    /**
     * 线程池执行任务
     * @param task
     */
    public void execute(Runnable task) {
       synchronized (workers) {
           //直接交给Worker线程执行
           if (workers.size() < coreSize) {
               Worker worker = new Worker(task);
               log.debug("创建Worker: {}, 任务: {}", worker, task);
               workers.add(worker);
               worker.start();
           }
           //加入阻塞队列暂存 -- 设置拒绝策略
           else {
               taskQueue.tryPut(rejectPolicy, task);
           }
       }
    }

}

3.3 测试自定义拒绝策略

3.3.1 拒绝策略-死等

当前工核心线程数为2，任务队列容量为2，待处理任务数量为8，测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(2, 2, TimeUnit.MILLISECONDS, 1000,
                TaskBlockingQueue::put);
        for (int i = 0; i < 8; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                	//假设工作线程耗时特别久
                    TimeUnit.MILLISECONDS.sleep(1000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
在死等的拒绝策略下，当工作线程无空闲且任务队列已满时，新增任务时将会一直等待到任务队列有空闲为止。

3.3.2 有时限等待 - 超时时间之内

现假设任务执行耗时为2s，超时等待时间为2s，拒绝策略为在1s内尝试将新任务加入任务队列，测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    //在1s内尝试将任务加到任务队列
                    queue.offer(task, 1000, TimeUnit.MILLISECONDS);
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下：
在这里插入图片描述
执行拒绝策略时，在超时时间1s内尝试将新任务加入任务队列，但是都加入失败，故最后4个任务中只成功执行了两个任务，另外两个任务因加入任务队列失败而执行失败。

3.3.3 有时限等待 - 超时时间之外

现假设任务执行耗时为2s，超时等待时间为2s，拒绝策略为在3s内尝试将新任务加入任务队列，测试类如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    //在3s内尝试将任务加到任务队列
                    queue.offer(task, 3000, TimeUnit.MILLISECONDS);
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
工作线程执行任务耗时为2s，而执行拒绝策略时，新增任务的超时等待时间为3s，则新任务可正常被加入到任务队列中，故4个任务全部被执行成功。

3.3.4 放弃任务执行

假设当前核心线程数和任务队列数都为1，待执行任务数量为4，测试类代码如下所示：

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    log.debug("放弃执行: {}", task);
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
当任务队列满以后，执行拒绝策略时，最后两个任务放弃了执行，故最终只有两个任务可被正常执行。

3.3.5 抛异常

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    throw new RuntimeException("任务执行失败...");
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
执行拒绝策略时，当新任务无法加入到任务队列时，将直接抛出异常。

3.3.6 调用者线程执行

public class TestMyPool {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(1, 1, TimeUnit.MILLISECONDS, 2000,
                (queue, task) -> {
                    task.run();
                });
        for (int i = 0; i < 4; i++) {
            int j = i;
            pool.execute(() -> {
                try {
                    //工作线程执行耗时为2s
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("===> {} ", j + 1);
            });
        }
    }
}

运行结果如下所示：
在这里插入图片描述
执行拒绝策略时，无法加入到任务队列的任务将交由调用者线程即main线程来执行，所有任务都可以被执行成功，但是负责执行的线程不一样。

JAVA并发编程实践-线程池-学习笔记
07-22
Java并发编程实践中的线程池是一个关键的概念，它在多线程编程中扮演着至关重要的角色，有效地管理和调度线程资源，以提高系统的性能和效率。线程池通过复用已存在的线程来减少线程的创建和销毁开销，避免了频繁的上...
Java并发编程：线程池的使用 - 平凡希 - 博客园1
08-04
Java并发编程中的线程池是提高系统效率的关键工具，它解决了频繁创建和销毁线程的问题。线程池通过复用已存在的线程来处理任务，从而避免了每次任务执行完毕后销毁线程的开销。在Java中，线程池的核心实现是`java....
Java并发编程-线程池底层工作原理
Java硬件工程师的博客
01-29 2594
关于线程池的具体介绍，可以参看ThreadPool线程池，这里主要介绍线程池底层工作原理。 1.线程池的底层工作原理 1.1.线程池的底层工作原理图 线程池的主要处理原理图和流程图如下 1.2.银行办理业务案例 为了便于理解，我们用银行的例子来说明银行网=线程池 corePoolsize=今日当值窗口。今日当值窗口由两个，当银行客人来了之后，先去候客厅等着，现在来了3个即3，4，5都来了，在候客厅等着，此时候客区也满了。突然，6，7，8三个人又来了，由于候客区也满了，此时可以用到maximumPoolS
Java并发编程之线程池详解
BUG糕手的博客
07-14 459
本文全面介绍了Java线程池的核心概念与应用。主要内容包括：线程池的作用（复用线程、控制并发数、提高响应速度）、ThreadPoolExecutor的核心参数（线程数、存活时间、队列等）及工作流程。文章还分析了Executors提供的四种常见线程池类型及适用场景，详细讲解了拒绝策略和最佳实践（推荐自定义参数、合理设置线程数、正确关闭线程池）。最后提供了完整的监控方法和示例代码，帮助开发者深入理解并优化线程池使用。线程池是Java高并发编程的关键技术，合理使用可显著提升系统性能。
Java并发编程-线程池
热门推荐
千月落
02-21 1万+
Java 中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。
Java并发编程 - 线程池ThreadPoolExecutor详解
qq_33240556的博客
08-17 1003
是Java中实现线程池的一种强大工具，它可以灵活地配置线程池的各种参数，以适应不同的应用场景。合理配置线程池可以显著提高系统的响应速度和吞吐量，同时减少资源消耗。在设计线程池时，应该根据具体的需求仔细考虑各种参数的选择，以确保线程池能够高效稳定地运行。
Java并发编程-ThreadPool线程池
Java硬件工程师的博客
01-29 5643
1.线程池的优势 1.1.引言 与数据库线程池类似，如果没有数据库连接池，那么每次对数据库的连接池都要new来获取连接池。重复的连接和释放操作会消费大量的系统资源，我们可以使用数据库连接池，直接去池中取连接池。 同样，在没有线程池之前，我们也是通过new Thread.start()来获取线程，现在我们也不需要new了，这样就能实现复用，使得我们系统变得更加高效。 1.2.为什么要使用线程池 例子： 10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。 现在是多核电脑，多个线程各
JAVA并发编程-线程池核心原理
励志成为一名优秀的全能型软件开发工程师。
02-20 2102
工作线程执行的run方法，是栈桢压栈执行，所以run方法里涉及到的内容都是GCRoot，run方法里涉及到了Worker对象的引用 -------> Worker ---------> ThreadPoolExecutor。无论线程构建之初，被认定为核心还是非核心，到后面都是工作线程，而且线程池再多维护一个工作线程的属性，很麻烦，而且对效率有影响。线程池构建线程，也是基于Thread t = new Thread()去构建，虽然在构建前，有一些判断上的不同，但是构建出来的都是线程，不分核心还是非核心！
Java并发编程-线程池（一）
gdr12的专栏
05-12 1228
Java并发编程之线程池的使用
并发编程-线程池
m0_51607909的博客
03-11 1335
关于线程池，查看源码可以看见，线程池的顶层接口是：Executor，只提供了execute方法，其下的实现非常多，常用的实现是ExecutorService，它提供了操作线程池的很多方法，例如开启线程池，关闭线程池，提交线程任务等等，我们使用的大部分线程池，几乎都是实现了ExecutorService接口。
Java并发编程 - 线程池原理
weixin_46619605的博客
08-20 1023
Java并发编程 - 线程池原理
JAVA面试题---线程池（Java并发编程）
Frank---7的博客
04-24 1371
CallerRunsPolicy，使用线程池的调用者所在的线程去执行被拒绝的任务，除非线程池被停止或者线程池的任务队列已有空缺。AbortPolicy，直接抛出一个任务被线程池拒绝的异常。DiscardPolicy，不做任何处理，静默拒绝提交的任务。DiscardOldestPolicy，抛弃最老的任务，然后执行该任务。自定义拒绝策略，通过实现接口可以自定义任务拒绝策略。
Java 后端开发 - 线程池原理深度剖析与应用
12-05
适用人群：Java 开发者，特别是希望深入了解多线程编程和线程池工作机制的技术人员。 使用场景及目标：适用于需要处理大量并发请求的应用系统中，帮助提高服务器资源利用率，确保系统的稳定性和效率。学习者可以掌握...
深入理解高并发编程-Java线程池核心技术
06-01
总结来说，理解Java并发编程中的线程和线程池技术，包括它们的实现方式、生命周期、执行顺序控制、异步计算模型以及线程安全问题，是提高程序性能和可扩展性的关键。通过合理使用线程池，我们可以有效地管理线程，...
深入理解高并发编程-Java线程池核心技术.rar
03-18
深入理解高并发编程-Java线程池核心技术 全面详解Java线程池核心技术
SSM企业物资管理系统h3109(程序+源码+数据库+调试部署+开发环境)带论文文档1万字以上，文末可获取，系统界面在最后面
2509_93102542的博客
11-21 763
在技术实现上，国外多采用成熟的开发框架和技术架构，注重系统的安全性、稳定性和可扩展性，同时积极融入大数据、人工智能等新技术，实现物资需求预测、智能库存优化等功能。基于此，开发一套基于SSM框架的企业物资管理系统，整合部门、员工、物资及各类业务流程管理功能，实现物资管理的数字化、规范化和高效化，成为解决企业物资管理痛点的必然需求。本课题旨在开发一套基于SSM框架的企业物资管理系统，围绕部门、员工、物资信息、物资申请、消息提醒、物资归还、物资入库、意见反馈八大核心功能模块，实现企业物资管理的全流程数字化。
2025最新 SpringCloud 教程，Nacos-总结，笔记19
最新发布
Rockandrollman的博客
11-25 52
2025最新 SpringCloud 教程，Nacos-总结，笔记19
Java原生网络编程-BIO与NIO
照母山挖洋芋
11-24 460
摘要：本文对比了Java原生JDK中的BIO(阻塞I/O)和NIO(非阻塞I/O)网络编程模型。BIO采用"一连接一线程"模式，存在线程资源浪费和性能瓶颈问题，可通过线程池优化为伪异步I/O模型。NIO通过Selector、Channel和Buffer三大核心组件实现非阻塞通信，支持单线程管理多个通道。重点介绍了NIO的Reactor模式、事件类型(OP_READ/OP_WRITE等)及服务端/客户端的不同关注点，展示了NIO相比BIO在高并发场景下的优势。（149字）
spring全局懒加载(default-lazy-init)导致的afterPropertiesSet不执行问题
豆豆的博客
11-21 516
Spring配置default-lazy-init="true"会导致所有Bean延迟初始化，影响afterPropertiesSet方法的执行时机。解决方案包括：1)为关键Bean显式设置lazy-init="false"；2)使用@Lazy(false)注解；3)编程式强制初始化；4)使用DependsOn控制顺序。最佳实践建议分层配置策略，核心组件立即初始化，业务组件懒加载，并通过配置文件分离和环境区分优化配置。实际应用中，Web应用的请求处理相关Bean和批处
《JAVA并发编程实践-线程池高级选项及任务执行框架注意事项学习笔记》
本文是关于《JAVA并发编程实践-线程池-学习笔记》中配置和调整线程池时使用的高级选项的总结，重点讲述了在任务执行框架的过程中需要注意的危险。其中包括线程复用原理、线程池的实现原理以及线程池的组成等内容。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值