6、共享模型之线程池

最新推荐文章于 2024-08-01 01:48:29 发布
最新推荐文章于 2024-08-01 01:48:29 发布
阅读量367 收藏
点赞数 1
分类专栏： 后台编程技术 # Java 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HadesLin/article/details/118831438
版权

该栏目讲叙多线程基础、共享模型的内存、管程、无锁、不可变设计和多线程并发工具

文章目录

自定义线程池

1、背景

  • ：线程是一种系统资源，每创建一个线程都要占用一定的内存。在高并发的情况下，如果为每个任务都创建一个新的线程，对内存的占用是相当大的；从 CPU 的角度出发，CPU 的数量有限，如果线程数越多，那么没有获取到 CPU 时间片的线程会被阻塞，引发线程上下文切换，从而导致系统性能。所以创建一批线程，让线程得到充分的利用，这样减少内存的占用，也可以减少线程的数量，避免它们频繁的发生上下文切换

2、图解

线程池图解

3、实现

  • 拒绝策略接口
@FunctionalInterface
public interface RejectPolicy<T> {

    void reject(BlockingQueue<T> queue, T task);

}
  • 阻塞队列
/**
 * 阻塞队列
 */
public class BlockingQueue<T> {

    /**
     * 任务容量
     */
    private final int capacity;

    /**
     * 任务队列
     */
    private final Deque<T> queue = new ArrayDeque<>();

    /**
     * 锁
     */
    private final ReentrantLock lock = new ReentrantLock();

    /**
     * 消费者条件
     */
    Condition emptyWaitSet = lock.newCondition();

    /**
     * 生产者条件
     */
    Condition fullWaitSet = lock.newCondition();

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

    /**
     * 获取任务
     *
     * @return 任务
     */
    public T take() {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                try {
                    System.out.println("任务队列串没有任务了...");
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            final T task = queue.removeFirst();
            System.out.println("获取的任务：" + task);
            emptyWaitSet.signal();
            return task;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 获取任务，带超时
     *
     * @param timeout  超时时间
     * @param timeUnit 超时单位
     * @return 任务
     */
    public T take(long timeout, TimeUnit timeUnit) {
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            while (queue.isEmpty()) {
                try {
                    if (nanos <= 0) {
                        System.out.println("获取任务超时...");
                        return null;
                    }
                    System.out.println("任务队列串没有任务了...");
                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            final T task = queue.removeFirst();
            System.out.println("获取的任务：" + task);
            emptyWaitSet.signal();
            return task;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 添加任务
     *
     * @param task 任务
     */
    public void put(T task) {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                try {
                    System.out.println("任务队列已经存储满...");
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("任务加入队列：" + task);
            queue.addLast(task);
            emptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 添加任务，带超时
     *
     * @param task     任务
     * @param timeout  超时时间
     * @param timeUnit 超时单位
     */
    public void put(T task, long timeout, TimeUnit timeUnit) {
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            while (queue.size() == capacity) {
                try {
                    System.out.println("任务队列已经存储满...");
                    nanos = fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("任务加入队列：" + task);
            queue.addLast(task);
            emptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 策略添加任务
     *
     * @param task   任务
     * @param policy 策略
     */
    public void put(T task, RejectPolicy<T> policy) {
        lock.lock();
        try {
            if (queue.size() == capacity) {
                policy.reject(this, task);
            } else {
                System.out.println("任务加入队列：" + task);
                queue.addLast(task);
                emptyWaitSet.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    /**
     * 获取队列大小
     *
     * @return 队列大小
     */
    public int getSize() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }

}
  • 线程池
/**
 * 线程池
 */
public class ThreadPool {

    /**
     * 线程核心数
     */
    private final int coreSize;

    /**
     * 任务队列
     */
    private final BlockingQueue<Runnable> taskQueue;

    /**
     * 线程集合
     */
    private final Set<Worker> workers = new HashSet<>();

    /**
     * 超时时长
     */
    private final long timeout;

    /**
     * 时间单位
     */
    private final TimeUnit timeUnit;

    /**
     * 拒绝策略
     */
    private final RejectPolicy<Runnable> policy;

    public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapacity, 
    			RejectPolicy<Runnable> policy) {
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;
        this.taskQueue = new BlockingQueue<>(queueCapacity);
        this.policy = policy;
    }

    /**
     * 执行任务
     *
     * @param task 任务
     */
    public void execute(Runnable task) {
        synchronized (workers) {
            if (workers.size() < coreSize) {
                Worker worker = new Worker(task);
                System.out.println("添加work:" + worker + ",task=" + task);
                workers.add(worker);
                worker.start();
            } else {
				// taskQueue.put(task);
                taskQueue.put(task, policy);
            }
        }
    }

    /**
     * 工作线程
     */
    class Worker extends Thread {

        private Runnable task;

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

        @Override
        public void run() {
            while (task != null || (task = taskQueue.take(timeout, timeUnit)) != null) {
                try {
                    System.out.println("正在执行...task=" + task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            synchronized (workers) {
                System.out.println("worker被移除，worker=" + this);
                workers.remove(this);
            }
        }
    }

}
  • 测试类
/**
 * 测试类
 */
public class TestDemo {

    public static void main(String[] args) {
        ThreadPool pool = new ThreadPool(2, 1000, TimeUnit.MILLISECONDS, 5, (queue, task) -> {
            // 一直等待
            queue.put(task);
            // 超时等待
            queue.put(task, 500, TimeUnit.MILLISECONDS);
            // 让调用者放弃任务
            System.out.println("放弃task=" + task);
            // 自己执行任务
            task.run();
            // 抛出异常
            throw new RuntimeException("任务执行失败，task=" + task);
        });
        for (int i = 0; i < 10; i++) {
            int index = i;
            pool.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("执行任务，序号：" + index);
            });
        }
    }

}

ThreadPoolExecutor

1、线程池状态

线程池状态
注意： ThreadPoolExecutor 使用 int 类型的高 3 位表示线程池状态，低 29 位表示线程数量。目的是仅使用一次 CAS 原子操作进行赋值

2、构造方法

  • public ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler)
    • corePoolSize：核心线程数（最多保留的线程数）
    • maximumPoolSize：最大线程数，救援线程数 = 最大线程数 - 核心线程数
    • keepAliveTime：生存时间（针对救急线程）
    • unit：时间单位（针对救急线程）
    • workQueue：阻塞队列
    • threadFactory：线程工厂（为线程创建时起名称）
    • handler：拒绝策略
      • AbortPolicy：让调用者抛出 RejectedExecutionException 异常，这是默认策略
      • CallerRunsPolicy：让调用者运行任务
      • DiscardPolicy：放弃本次任务
      • DiscardOldestPolicy：放弃队列中早的任务，本任务取而代之

3、成员方法

描述方法
执行任务void execute(runnable)
执行任务，并可获取返回值Future submit(callback)
执行集合中所有任务List invokeAll(callbacks)
执行集合中任一任务T invokeAny(callbacks)
线程是否关闭boolean isShutdown()
线程是否终结boolean isTerminated()
指定时间内终结boolean awaitTermination(timeout, unit)

4、案例

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 使用构造函数创建线程池
        final ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 1000,
                TimeUnit.MILLISECONDS, new SynchronousQueue<>());
        // 执行任务
        pool.execute(() -> System.out.println("执行任务1"));
        
        // 执行任务有返回值
        final Future<Integer> future = pool.submit(() -> {
            System.out.println("执行任务2");
            return 100;
        });
        System.out.println("执行结果：" + future.get());

        // 执行集合内所有任务
        List<Callable<Boolean>> tasks = new ArrayList<>();
        tasks.add(() -> {
            System.out.println("执行任务3");
            return true;
        });
        List<Future<Boolean>> results1 = pool.invokeAll(tasks);
        System.out.println("执行结果：" + results1);

        // 执行集合中任一任务
        Boolean result = pool.invokeAny(tasks);
        System.out.println("执行结果：" + result);

        // 其他方法
        System.out.println(pool.isShutdown());
        System.out.println(pool.isTerminated());
        pool.awaitTermination(1, TimeUnit.SECONDS);

        // 关闭线程池
        pool.shutdown();
    }

}

Executors 工具类

1、常用方法

  • Executors.newFixedThreadPool(coreSize)：创建固定大小的线程池
  • Executors.newSingleThreadExecutor()：创建单个线程的线程池
  • Executors.newCachedThreadPool()：创建具有缓存功能的线程池
  • Executors.newScheduledThreadPool(coreSize)：创建具有调度功能的线程池

2、案例

public class ExecutorsDemo {

    public static void main(String[] args) {
        // 创建固定大小的线程池
        final ExecutorService pool2 = Executors.newFixedThreadPool(2);
        // 创建单个线程的线程池
        final ExecutorService pool3 = Executors.newSingleThreadExecutor();
        // 创建具有缓存功能的线程池
        final ExecutorService pool4 = Executors.newCachedThreadPool();
        // 创建具有调度功能的线程池
        final ScheduledExecutorService pool5 = Executors.newScheduledThreadPool(2);

        // 定时任务
        pool5.scheduleAtFixedRate(() -> System.out.println("执行定时任务"), 1, 2, TimeUnit.SECONDS);

        // 延时任务
        pool5.schedule(() -> System.out.println("执行延时任务"), 3, TimeUnit.SECONDS);
    }

}

Fork & Join

1、概述

  • ：将一个大任务拆分为算法上相同的小任务，直至不能拆分可以直接求解。它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型运算

2、案例

/**
 * 使用Fork & Join方式 拆分1-5之间的和
 */
public class ForkDemo {

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        final Integer value = pool.invoke(new Task(1, 5));
        System.out.println("结果：" + value);
    }

}

class Task extends RecursiveTask<Integer> {

    private final int begin;

    private final int end;

    public Task(int left, int right) {
        this.begin = left;
        this.end = right;
    }

    @Override
    protected Integer compute() {
        if (begin == end) {
            return begin;
        }
        if (end - begin == 1) {
            return begin + end;
        }
        int mid = (end + begin) / 2;
        Task task1 = new Task(begin, mid);
        task1.fork();
        Task task2 = new Task(mid + 1, end);
        task2.fork();

        return task1.join() + task2.join();
    }

}
HadesLin
关注
专栏目录
Java并发编程(九) : 自定义简单线程池、Java线程池详解、ThreadPoolExecutor、Executors工具类、Fork/Join框架
Guizy
01-18 2370
8. 共享模型之工具 8.1 线程池 池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。 线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。 这里借用《Java 并发编程的艺术》提到的来说一下使用线程池的好处： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要的等到线
共享模型之工具(二)
xp_xpxp的博客
02-17 338
自定义线程池,tomcat底层线程池使用
8. 共享模型之工具-线程池
liuhehe的博客
11-11 190
8.1 线程池 2. ThreadPoolExecutor 1) 线程池状态 ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量 从数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING 这些信息存储在一个原子变量 ctl 中，目的是将线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作 进行赋值 // c 为旧值， ctlOf 返回结果为新值 ctl.
支持配额的共享线程池
唯有思考没停
03-03 245
受@放翁_文初的&lt;逻辑划分线程池&gt; 一文的启发, 用了几个小时动手实现了一个简陋支持配额的共享线程池. 基本思路与放翁相同, 区别在于引入了两种线程分配策略: 悲观策略 简单的共享一个线程池, 最容易出现的问题就是不同类型任务(或事件)在随机争抢线程资源时, 可能出现”饿死”现象(即抢不到线程). 因此, 悲观策略的宗旨是绝对的保证每种任务都会被分配到预留的(reserve)...
Java并发（二）线程池详解
最高永远来自最下
09-15 280
一、前言 程序的所有业务逻辑都是跑在线程上的，每个进程都由一个主线程和N个子线程组成，每个线程都要消耗系统资源，如果不停地创建线程，那么系统资源最终会耗尽，会出现卡顿卡死的情况，这时候就需要对线程进行管理，控制线程的数量、线程重用等方案就出来，避免过度地消耗系统资源，同时也提高了运行效率。那么如何对线程进行管理呢？这就要涉及到Java的池化技术，我们来研究一下什么是池化技术。 1、池化技术 池化技术简单点来说，就是提前申请好大量掉系统资源，以备不时之需。池化技术能够减少资源对象的创建次数，提高程序的性能，特
Tomcat 6.0 共享线程池的配置Shared Executor Thread pool
zll_files的专栏
09-09 2016
修改 conf/server.xml  文件 配置很简单  第一步，打开共享的线程池   name="Catalina">             name="tomcatThreadPool" namePrefix="catalina-exec-"       maxThreads="1000" minSpareThreads="50" maxIdleTime="60000
c++多线程，多进程通讯模型，死锁，线程池，单例模式的实现，共享指针，atomic等等
最新发布
10-20
c++多线程，多进程通讯模型，死锁，线程池，单例模式的实现，共享指针，atomic等等
Java执行模型与线程池优化
# 1. Java执行模型概述 ## 1.1 Java执行模型基础概念 在Java中，执行模型指的是Java程序在运行过程中的执行方式和规则。Java执行模型是基于线程的，并且支持多...Java的多线程执行模型是基于线程池的。线程池是一种管
大语言模型应用指南：线程
AI天才研究院
06-06 847
大语言模型应用指南：线程 1. 背景介绍 随着人工智能技术的不断发展,大型语言模型(Large Language Models, LLMs)已经成为自然语言处理领域的关键技术之一。这些模型通过在海量文本数据上进行预训练,学习了丰富的语言知识和上下文关系,可以应用于各种自然语言处理任务,如机器翻译、
Linux线程安全，死锁，生产消费模型，线程池
徐凤年llll的博客
12-02 946
然后你第二天准备去学习了，卷的不行，直接凌晨三点就跑过来，拿着钥匙进入自习室上自习了，然后卷了3小时之后，你想出来上个厕所，一打开门发现外面站的一堆人，都在叽叽喳喳的讨论谁先来的，怎么来的这么早？等你回来的时候，你又打开门，又来里面上了3小时自习，你感觉自己饿的不行了，在不吃饭就饿死在里面了，所以你打开门，准备出去吃饭了，然后突然你自己感觉负罪感直接拉满，我凌晨3点好不容易抢到自习室，现在离开是不太亏了，所以你又打开自习室回去上自习去了，别人当然竞争不过你呀！即为3种关系，两个角色，1个交易场所。
常用的四种线程池分享
杨杨杨~~的博客
09-10 526
常用的四种线程池分享 1、newCachedThreadPool /*创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 优点: 1、工作线程的创建数量几乎没有限制 2、长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)， 则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。 缺点...
理解多线程共享与线程池
weixin_30296405的博客
09-05 127
最近在写程序的时候，突然感觉以前对线程的了解太少了。对多线程数据共享和单线程池的概念给弄混了! （1）单线程池作用主要是用来调度当前情况下只允许一个线程运行，但是可以压入多个线程，这些线程彼此间应该是无关的，不应该存在数据共享 参考 http://wawlian.iteye.com/blog/1315256 （2）多线程数据共享，多个线程共享数据 参考 ht...
线程池执行父子任务，导致线程死锁
ql_7256的博客
03-05 1749
一次线程池的不当使用，导致了现场出现了线程死锁，接口一直不返回。而且由于这是一个公共的线程池，其他使用了次线程池的业务也一直阻塞，系统出现了OOM，不过是幸好是线程同事测试出来的，没有直接在生产坏境中出现这种事故，否则后果不堪设想。
多任务共用一个大的线程池还是每个任务单独使用线程池？
2301_76607156的博客
03-25 825
每一个线程池最好做单一任务，尽可能的减少多任务类型混合使用一个线程池。特别是如果某一类任务延迟一定时间会导致问题的情况下，例如通过心跳维持某种状态当延迟执行后服务端可能就任务当前连接失效从而进行剔除。但是线程池的使用也是需要结合实际情况，用合适的方式来实现功能才是最好的。
JUC——共享模型之工具
m0_51710682的博客
08-01 780
这时 Thread-4 释放了 permits，接下来 Thread-0 竞争成功，permits 再次设置为 0，设置自己为 head 节点，断开原来的 head 节点，unpark 接 下来的 Thread-3 节点，但由于 permits 是 0，因此 Thread-3 在尝试不成功后再次进入 park 状态。，是阻塞式锁和相关的同步器工具的框架。提交任务的时，即使有线程池里的线程从阻塞队列中获取不到任务，如果线程池里的线程数还是小于核心线程数，那么依然会继续创建线程，而不是复用已有的线程。
SpringBoot：详解@EnableAsync + @Async 实现共享线程池
Oxye
07-27 9244
锲子 平时的开发中，可以看到很多地方要使用多线程技术， 比如 1.处理大数据量的数据时，可以采用线程池，充分利用多核优势 2.用户触发一个较长的流程时，可以将一部分处理逻辑，另起一个线程异步处理，减少用户等待时间 不过线程是一种宝贵的资源，一个系统运行在服务器上，要根据CPU的数量来合理设置并发线程数量。 如果一个系统中每个线程使用者都自己定义线程或者线程池，有一些可见的不良后果 比如 1.系统各处启线程太多，导致CPU切换上下文的消耗 2.定义线程池的参数不一致，导致各种不同实现共存难以处理和排查问题
Java8 parallelStream——共享线程池对性能解析
weixin_42330218的博客
09-30 3517
最近做压测中发现一个应用中cpu过高，导致接口超时rt情况有些不大稳定，jstack打印线程一直在parallelStream相关的代码出进行计算。故对parallelStream相关做一下研究，找一下优化方法。 java8并行流parallelStream，相信很多人都喜欢用，特别方便简单。但是有多少人真正知道里面采用的共享线程池对密集型任务，高并发下的性能影响呢 可能你的一个应用里面...
JAVA 并发编程-多个线程之间共享数据（六）
热门推荐
何静媛
07-25 4万+
多线程共享数据的方式： 1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，卖票系统就可以这么做。2，如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，例如，设计4个线程。，其中两个线程每次对j增加1，另外两个线程对j每次减1，银行存取款 有两种方法来解决此类问题：将共享数据封装成另外一个对象，然后将这个对象逐一传递
JAVA线程池的几种使用方式以及线程同步详解
yingziisme的博客
10-07 4773
JAVA创建线程的方法 继承Thread类 public class MyThread extends Thread { @Override public void run(){ // do something } } 实现Runnable接口 public class MyRunnable implements Runnable{ @Ove...
深入解析多线程控制与HTTP线程池模型技术
线程池模型是一种资源池化技术，它预先创建一定数量的线程，并将这些线程放入一个池中，使用时从池中分配线程，完成任务后将线程返回池中，而不是每次都创建或销毁线程。线程池通过减少线程创建和销毁的开销，提高...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值