多线程 ---- 线程池

最新推荐文章于 2024-05-17 16:36:26 发布
最新推荐文章于 2024-05-17 16:36:26 发布
阅读量112 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45914985/article/details/106395908
版权

线程的每次启动和销毁都需要消耗很大的性能, 所以引入线程池; 线程池最大的好处就是减少每次启动, 销毁线程的损耗.

(1) 下面以一个送快递的案例具体引入 JDK 的线程池:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadVsThreadPool {

    public static void main(String[] args) {

        // 1. 没有使用线程, 送快递
        // 相当于老板自己送快递, 再干自己的活
        System.out.println("送快递到北京"); // 模拟送快递, 有可能送快递是比较耗时的
        System.out.println("送快递到上海");
        System.out.println("处理自己的业务");

        // 2. 使用手动创建线程的方式, 送快递
        // 相当于雇佣了两个人, 他们在送快递, 此时老板也在干自己的事情
        new Thread(()->{
            System.out.println("送快递到北京");
        }).start();
        new Thread(()->{
            System.out.println("送快递到上海");
        }).start();
        System.out.println("处理自己的业务");

        // 3. 使用 JDK 的线程池来送快递
        // 创建线程池对象, 相当于开了一家送快递的公司, 专门处理送快递的任务
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                4, // 核心线程数: 快递公司的正式员工 ---- 线程
                10, // 最大线程数: 快递公司的总员工(正式工 + 临时工) ---- 线程
                // 临时工 + 空闲时间: 正式员工数量不够处理任务的时候, 招聘临时工, 临时工常超过空闲时间, 就解雇
                60, // 空闲时间数
                TimeUnit.SECONDS, // 时间单位
                new ArrayBlockingQueue<>(1000), // 阻塞队列: 快递公司的仓库, 用来保存快递包裹 ---- 存放线程的容器
                new ThreadFactory() { // 匿名内部类
                    @Override
                    public Thread newThread(Runnable r) { // 线程的工厂类: 快递公司招聘标准 ---- 创建线程的方式
                        return new Thread(r);
                    }
                },
                // 拒绝策略: 接受到新的快递单, 但此时仓库容量不够存放快递包裹
//                new ThreadPoolExecutor.AbortPolicy() // 抛异常的方式:RejectedExecutionException
//                new ThreadPoolExecutor.CallerRunsPolicy() // 谁把包裹交给我的, 让他自己去送(execute 代码所在线程自己执行)
//                new ThreadPoolExecutor.DiscardOldestPolicy() // 把仓库中最旧的包裹丢弃
                new ThreadPoolExecutor.DiscardPolicy() // 把仓库中最新的丢掉
        );
        pool.execute(()->{
            System.out.println("送快递到北京");
        });
        pool.execute(()->{
            System.out.println("送快递到上海");
        });
        System.out.println("处理自己的业务");
    }

}

这里分别使用三种方法实现送快递操作, 分别是没有使用线程, 手动创建线程,
使用 JDK 的线程池来送快递

对线程池的属性加以介绍:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
(2) 下面介绍一些简单的线程池

他们都是默认一些属性的值, 方便使用

    ExecutorService pool = Executors.newSingleThreadExecutor();
    ExecutorService pool2 = Executors.newFixedThreadPool(4);
    ExecutorService pool3 = Executors.newScheduledThreadPool(4);
    ExecutorService pool4 = Executors.newCachedThreadPool();

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
(3) 使用一下固定大小的线程池(FixedThreadPool)

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

public class runFixedThreadPoolTest {

    private static ExecutorService FIXED_POOL = Executors.newFixedThreadPool(4);

    // 固定大小的线程池
    public static void runFixedThreadPool(Runnable task) {
        FIXED_POOL.execute(task);
    }

    public static void main(String[] args) {
        runFixedThreadPool(()->{
            System.out.println("送快递到北京");
        });
        runFixedThreadPool(()->{
            System.out.println("送快递到上海");
        });
        System.out.println("干自己的事情");
    }
}

(4) 使用一下计划任务线程池(定时任务线程 ScheduledThreadPool)

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolTest {
    private static ScheduledExecutorService SCHEDULED_POOL = Executors.newScheduledThreadPool(4);

    public static void main(String[] args) {
        SCHEDULED_POOL.scheduleAtFixedRate(()->{
            Date date = new Date();
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(df.format(date));
        }, 1, // 延迟多少秒之后执行一次
                1, // 每间隔多少秒执行一次
                TimeUnit.SECONDS); // 时间单位
        SCHEDULED_POOL.scheduleAtFixedRate(()->{
            System.out.println("abc");
        }, 0, 2, TimeUnit.SECONDS);
    }
}

分析一下这个打印结果:
在这里插入图片描述
在这里插入图片描述
(5) 自己实现一个定时器(定时任务线程池)

import java.util.Date;
import java.util.concurrent.PriorityBlockingQueue;

public class MyScheduledThreadPool {

    //员工
    private MyTimer[] threads; // 这里可以去掉, 直接在构造方法里 new 就可以了

    // 仓库(优先级队列)
    private PriorityBlockingQueue<MyTimerTask> queue = new PriorityBlockingQueue<>();

    public MyScheduledThreadPool(int capacity) {
        threads = new MyTimer[capacity];
        for (int i = 0; i < capacity; i++) {
            threads[i] = new MyTimer(queue);
            threads[i].start();
        }
    }

    // 模拟执行定时任务的方法: 任务, 延迟时间(毫秒), 间隔时间
    public void schedule(Runnable runnable, long delay, long period) {
        MyTimerTask task = new MyTimerTask(runnable, new Date().getTime() + delay, period);
        // 这里考虑到一种特殊情况: 如果有个线程的延迟时间是很久, 另外一个延迟时间短的要先执行, 就会出错, 所以必须使用 notify进行唤醒
        synchronized (queue) {
            queue.put(task);
            queue.notifyAll();
        }
    }

    // 员工
    private static class MyTimer extends Thread {
        private PriorityBlockingQueue<MyTimerTask> queue;

        public MyTimer(PriorityBlockingQueue<MyTimerTask> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    // take 和 put 方法在达到上限和下限的时候, 会阻塞等待
                    // poll 和 offer 是非阻塞方法. 如果达到上限和下限的时候, 返回空
                    MyTimerTask task = queue.take();
                    synchronized (queue) {
                        long current = System.currentTimeMillis(); // 获取当前时间戳
                        if (current < task.next) {
                            // 如果当前时间小于执行下一个的时间, 就等待
                            queue.wait(task.next - current);
                            // 等待直到满足下次执行时间, 需要从仓库中重新获取包裹 ---> 可能有时间更短的任务(更紧急的包裹需要派送)
                            queue.put(task); // 之前已经从仓库取出来在等待了, 要重新放回去, 此处并没有执行
                        } else {
                            task.run();
                            if (task.period > 0) {
                                // 如果时间间隔大于0
                                task.next = task.next + task.period; // 下次执行时间修改为当前的 next + period
                                queue.put(task);
                            }
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 定时任务
    private static class MyTimerTask implements Runnable, Comparable<MyTimerTask> {
        private Runnable runnable;
        private long next; // 下次执行时间
        private long period; // 间隔时间

        public MyTimerTask(Runnable runnable, long next, long period) {
            this.runnable = runnable;
            this.next = next;
            this.period = period;
        }

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

        @Override
        public int compareTo(MyTimerTask o) {
            return Long.compare(next, o.next);
        }
    }

    public static void main(String[] args) {
        MyScheduledThreadPool pool = new MyScheduledThreadPool(4);
        pool.schedule(()->{
            System.out.println("ABC");
        }, 999999999,1000);
        pool.schedule(()->{
            System.out.println("D");
        }, 0,1000);

    }
}

(6) 自己实现一个 JDK 的线程池

package Java05_28;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class MyThreadPool {

    private BlockingQueue<Runnable> queue; // 仓库: 可以使用自定义的阻塞式队列

    // 创建快递公司
    public MyThreadPool(int corePoolSize, int capacity) {
        // 创建仓库
        queue = new ArrayBlockingQueue<>(capacity);
        // 招聘员工
        for (int i = 0; i < corePoolSize; i++) {
            new MyThread(queue).start();
        }
    }

    // 快递公司开放送快递的接口(营业点), 客户调用这个接口(去营业点办业务), 快递仓库存放包裹(往阻塞队列里面加元素)
    private void execute(Runnable task) throws InterruptedException {
        queue.put(task);
    }

    // 正式员工
    private static class MyThread extends Thread{
        private BlockingQueue<Runnable> queue;
        public MyThread(BlockingQueue<Runnable> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                // 员工不停的从仓库取包裹, 没有进入到仓库的就阻塞等待, 取到了就执行
                while (true) {
                    Runnable task = queue.take();
                    task.run();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
JIAYU.
关注
Java线程-线程池-固定大小
brimen的博客
03-11 1522
Sun在Java5当中，对线程的类库做了大量的扩展，线程池是Java5的新特征之一。 有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类。 线程池的思想是一种对象池的思想，开辟了一块内存空间，里面放了很多的线程，线程的执行调度由池管理器来进行处理，当有线程任务时，会从池子当中取一个进行执行，当任务执行完成以后，重新放入池子，以便于给其它任务...
ASP.Net 多线程-IIS搭建-线程池-video
08-30
本教程围绕"ASP.Net 多线程-IIS搭建-线程池-video"的主题，深入探讨了以下几个关键知识点： 1. **委托与多线程**：在.NET框架中，委托是一种类型安全的函数指针，可以用于传递方法作为参数。在多线程环境中，委托常...
多线程-线程池
qq_44715376的博客
08-24 1189
线程池是多线程的处理形式，在处理的过程中将任务添加到队列中，然后在创建线程后启动这些任务。线程池会维护这多条线程，等待监督管理者分配并发执行的任务。线程池不仅要能够保证内核的充分利用，还能防止过度调用。
Java多线程 - 线程池
honvin的博客
09-26 3727
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。 好处 提高响应速度（减少了创建新线程的时间） 降低资源消耗（重复利用线程池中线程，不需要每次都创建） 便于线程管理 core Poolsize：核心池的大小 maximum Poo|size：最大线程数 keepAliveTime：线程没有任务时最多保持多长时间后会终止 JDK5.0起提供
多线程--线程池
qq_45489824的博客
05-11 473
多线程--线程池 线程池是什么： 线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问...
多线程学习-线程池
qq_65568592的博客
04-05 2449
一个线程池所创建的线程分为核心线程和临时线程，核心线程则是在创建后会一直存在，直到线程池关闭，而临时线程则是当提交的任务过多时应急使用的，临时线程也会正常工作，但在工作结束后如果在一定时间内没有其他任务，则会被销毁。要注意的是，只有当等待队列的任务占满了整个队列，后面再提交任务时才会创建临时线程，并且创建的临时线程处理的任务并不是等待队列中的任务，而是队列满后后面再提交的任务。如果创建的临时线程达到最大数量，此时仍有任务被提交时就需要选择一种应对策略来处理后面提交的任务。
04多线程--线程池
m0_65110309的博客
05-17 1372
线程池是一种软件设计模式，用于管理和复用线程资源，以提高程序性能和资源利用率。线程池的设计会预先创建一定数量的线程，并将这些线程置于一个池中等待任务分配，而不是为每个新任务单独创建线程。
多线程---线程池的使用
热门推荐
意田天的博客
08-22 1万+
线程池的使用
多线程--02--01--线程池常见面试题
na_tion的专栏
03-27 3543
一、线程池参数（7-4-4） 1、corePoolSize：线程池的基本大小，当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。说白了就是，即便是线程池里没有任何任务，也会有corePoolSize个线程在候着等任务。 2、maximumPoolSize:最大线程数，不管你提交多少任务，线程池里最多工作线程数就是maximumPoolSize。 3、keepAliveTime:线程的存活时间。
线程-----线程池
qq_44816731的博客
03-13 369
线程中线程池的概念
多线程---线程池核心参数
oDianZi1234567的博客
07-22 5579
常用参数总结： 关于Java线程池的参数设置： 线程池是Java多线程里开发里的重要内容，使用难度不大，但如何用好就要明白参数的含义和如何去设置。干货里的内容大多是参考别人的，加入了一些知识点的扩充和看法。希望能对多线程开发学习的童鞋有些启发和帮助。 构造方法详细信息 ThreadPoolExecutor public ThreadPoolExecutor(intcoreP...
线程-线程池-锁-集合-Map-队列.docx
05-18
线程的状态管理是多线程编程中非常重要的部分。Java线程有六种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。NEW表示线程刚创建还未启动，RUNNABLE表示线程在执行或等待CPU资源，BLOCKED表示...
多线程简单应用-线程池
04-19
另一个常用的是Executors工具类，它提供了一些静态工厂方法，方便地创建不同类型的线程池，如固定大小的线程池、单线程线程池和缓存线程池。 线程池的工作流程大致如下： 1. 当提交一个任务到线程池时，线程池会...
前端初始化资源包初始化前端
10-01
.....................
vmware ubuntu22.04安装教程.docx
最新发布
10-01
vmware ubuntu22.04安装教程
语音处理相关的代码------matlab实现_______________开箱即用_soundProcess.zip
10-01
语音处理相关的代码------matlab实现_______________开箱即用_soundProcess
numpy-2.1.1-cp313-cp313t-macosx-14-0-x86-64.whl
10-01
numpy
用于用户故事分类的数据集_UserStoriesDataSet-.zip
10-01
用于用户故事分类的数据集_UserStoriesDataSet-
Java实现逻辑回归（对iris数据集分类）_LogisticRegression.zip
10-01
Java实现逻辑回归（对iris数据集分类）_LogisticRegression
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值