阻塞队列和线程池

最新推荐文章于 2023-08-14 21:49:18 发布
最新推荐文章于 2023-08-14 21:49:18 发布
阅读量178 收藏
点赞数
分类专栏： JAVA基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/super_marie/article/details/119152091
版权

阻塞队列

1. 阻塞队列的定义

  • 首先队列是一种特殊的线性表，它只能够在表的后端（rear）进行数据插入，在表的前端（front）进行数据获取；和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。
    在这里插入图片描述

  • 支持阻塞的含义：

    1. 支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满。
    2. 支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空。

2. 阻塞队列的使用场景

  • 阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。

3. 阻塞队列的相关类及相关方法简介

  • BlockingQueue

    • 该类是阻塞队列的父类，他是一个接口类，其余的阻塞队列都需要继承它。

    • BlockingQueue中并非只有阻塞方法，也有非阻塞的方法：
      在这里插入图片描述

      • 抛出异常：当队列满时，如果再往队列里插入元素，会抛出IllegalStateException（"Queuefull"）异常。当队列空时，从队列里获取元素会抛出NoSuchElementException异常。
      • 返回特殊值：当往队列插入元素时，会返回元素是否插入成功，成功返回true。如果是移除方法，则是从队列里取出一个元素，如果没有则返回null。
      • 一直阻塞：当阻塞队列满时，如果生产者线程往队列里put()元素，队列会一直阻塞生产者线程，直到队列可用或者响应中断退出。当队列空时，如果消费者线程从队列里take()元素，队列会阻塞住消费者线程，直到队列不为空。
      • 超时退出：当阻塞队列满时，如果生产者线程往队列里插入元素，队列会阻塞生产者线程一段时间，如果超过了指定的时间，生产者线程就会退出。

  • 常用的阻塞队列有以下几种，都是继承了BlockingQueue接口类的：

    • ArrayBlockingQueue
      • 一个由数组结构组成的有界阻塞队列。
      • 该阻塞队列是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。默认情况下不保证线程公平的访问队列，所谓公平访问队列是指阻塞的线程，可以按照阻塞的先后顺序访问队列，即先阻塞线程先访问队列。非公平性是对先等待的线程是非公平的，当队列可用时，阻塞的线程都可以争夺访问队列的资格，有可能先阻塞的线程最后才访问队列。初始化时有参数可以设置
    • LinkedBlockingQueue
      • 一个由链表结构组成的有界阻塞队列。
      • 该阻塞队列是一个用链表实现的有界阻塞队列。此队列的默认最大长度为Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。
    • PriorityBlockingQueue
      • 一个支持优先级排序的无界阻塞队列。
      • 该阻塞队列是一个支持优先级的无界阻塞队列。默认情况下元素采取自然顺序升序排列。也可以自定义类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue时，指定构造参数Comparator来对元素进行排序。需要注意的是不能保证同优先级元素的顺序。
    • DelayQueue
      • 一个使用优先级队列实现的无界阻塞队列。
      • 该阻塞队列是一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue来实现。队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。
      • DelayQueue可以用作缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。
    • SynchronousQueue
      • 一个不存储元素的阻塞队列。
      • 该阻塞队列是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合传递性场景。SynchronousQueue的吞吐量高于LinkedBlockingQueue和ArrayBlockingQueue。
    • LinkedTransferQueue
      • 一个由链表结构组成的无界阻塞队列。
      • 该阻塞队列主要多了tryTransfer和transfer两个方法
        1. transfer()
          • 如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer()方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer()方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。
        2. tryTransfer()
          • tryTransfer()方法是用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer()方法的区别是tryTransfer()方法无论消费者是否接收，方法立即返回，而transfer()方法是必须等到消费者消费了才返回。
    • LinkedBlockingDeque
      • 一个由链表结构组成的双向阻塞队列。
      • 该阻塞队列是一个由链表结构组成的双向阻塞队列。所谓双向队列指的是可以从队列的两端插入和移出元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。
      • 该阻塞队列多了addFirst()、addLast()、offerFirst()、offerLast()、peekFirst()和peekLast()等方法，以First单词结尾的方法，表示插入、获取（peek）或移除双端队列的第一个元素。以Last单词结尾的方法，表示插入、获取或移除双端队列的最后一个元素。另外，插入方法add()等同于addLast()，移除方法remove()等效于removeFirst()。但是take()方法却等同于takeFirst()，不知道是不是JDK的bug，使用时还是用带有First和Last后缀的方法更清楚。在初始化LinkedBlockingDeque时可以设置容量防止其过度膨胀。另外，双向阻塞队列可以运用在工作窃取模式中。

4. 阻塞队列的注意点

  1. 有界无界概念
    • 有限队列就是长度有限，满了以后生产者会阻塞，无界队列就是里面能放无数的东西而不会因为队列长度限制被阻塞，当然空间限制来源于系统资源的限制，如果处理不及时，导致队列越来越大越来越大，超出一定的限制致使内存超限，操作系统或者JVM帮你解决烦恼，直接把你 OOM kill 省事了。
      • 无界也会阻塞，为何？因为阻塞不仅仅体现在生产者放入元素时会阻塞，消费者拿取元素时，如果没有元素，同样也会阻塞。
  2. ArrayBlockingQueue和LinkedBlockingQueue实现的区别
    1. 队列中锁的实现不同
      • ArrayBlockingQueue实现的队列中的锁是没有分离的，即生产和消费用的是同一个锁；
      • LinkedBlockingQueue实现的队列中的锁是分离的，即生产用的是putLock，消费是takeLock
    2. 在生产或消费时操作不同
      • ArrayBlockingQueue实现的队列中在生产和消费的时候，是直接将枚举对象插入或移除的；
      • LinkedBlockingQueue实现的队列中在生产和消费的时候，需要把枚举对象转换为Node<E>进行插入或移除，会影响性能
    3. 队列大小初始化方式不同
      • ArrayBlockingQueue实现的队列中必须指定队列的大小；
      • LinkedBlockingQueue实现的队列中可以不指定队列的大小，但是默认是Integer.MAX_VALUE

5. 代码示例

/**
 * 实现一个固定时间后获取数据输出的生产者、消费者模型
 */


/**
 * 实际存放的数据类
 */
class Order {
    private int price;
    private String name;

    public Order(int price, String name) {
        this.name = name;
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    public String getName() {
        return name;
    }
}

/**
 *  存放元素的封装
 *  该封装是需要存放进 DelayQueue中的，而查看DelayQueue<E extends Delayed>
 *    其中的元素是需要继承Delayed类的
 */
class ItemVo<T> implements Delayed {
    private long responseTime;   //延迟时间
    private T data;      //真实的存储数据

    public ItemVo(long delayTime, T d) {
        responseTime = delayTime*1000 + System.currentTimeMillis();
        data = d;
    }

    public long getResponseTime() {
        return responseTime;
    }

    public T getData() {
        return data;
    }
    
    //获取当前剩余时间
    @Override
    public long getDelay(TimeUnit timeUnit) {
        long remainingTime = timeUnit.convert(responseTime - System.currentTimeMillis(),
                timeUnit);
        return remainingTime;
    }

    //比较不同任务之间的剩余时间大小
    @Override
    public int compareTo(Delayed delayed) {
        long t = this.getDelay(TimeUnit.MILLISECONDS) - delayed.getDelay(TimeUnit.MILLISECONDS);
        if (t == 0) {
            return 0;
        } else if (t < 0) {
            return -1;
        } else {
            return 1;
        }
    }
}

import java.util.concurrent.DelayQueue;

//生产者线程
class PutOrder implements Runnable {
    public DelayQueue<ItemVo<Order>> queue;

    public PutOrder(DelayQueue<ItemVo<Order>> q) {
        queue = q;
    }

    /**
     * 生产者线程负责将数放入到DelayQueue中，以供消费者去获取
     */
    @Override
    public void run() {
        Order order3 = new Order(100, "中美关系");
        ItemVo<Order> item3 = new ItemVo<>(10, order3);
        queue.offer(item3);

        Order order1 = new Order(55, "三体");
        ItemVo<Order> item1 = new ItemVo<>(5, order1);
        queue.offer(item1);

        Order order2 = new Order(88, "1740");
        ItemVo<Order> item2 = new ItemVo<>(8, order2);
        queue.offer(item2);
        
        System.out.println("数据存放完毕");
    }
}

//消费者线程
class FetchOrder implements Runnable {

    public DelayQueue<ItemVo<Order>> queue;

    public FetchOrder(DelayQueue<ItemVo<Order>> q) {
        queue = q;
    }
    
    /**
     * 消费者线程从DelayQueue中获取元素（因为DelayQueue本身就是按优先级排序的阻塞队列，
     * 所以获取的队列元素一定是延时最短的元素），DelayQueue本身是阻塞队列，当使用take()
     * 这个阻塞方法能够获取元素时，表示条件成立，即获取时间到达，否则会一直阻塞，无法获取到元素
     */
    @Override
    public void run() {
        System.out.println("enter FetchOrder run!");
        while (true) {
            try {
                ItemVo<Order> itemVo = queue.take();
                Order order = (Order)itemVo.getData();
                System.out.println("Order name = " + order.getName() +
                        ", price = " + order.getPrice() + ", this time = " + System.currentTimeMillis()
                + ", itemVo time = " + itemVo.getResponseTime());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Test {

    //使用DelayQuene实现存储元素特定时间后被获取的功能
    public static void main(String[] args) throws InterruptedException {

        //首先创建一个queue
        DelayQueue<ItemVo<Order>> queue = new DelayQueue<ItemVo<Order>>();

        //构建出生产者和消费者线程
        new Thread(new PutOrder(queue)).start();
        new Thread(new FetchOrder(queue)).start();

        //主线程做计时操作
        for (int i = 0; i < 100; i++) {
            Thread.sleep(500);
            System.out.println(i*500);
        }
    }
}

线程池

1. 使用线程池的好处

  1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。 如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
  3. 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

2. 浅显的实现一个自定义线程池

  • 线程池简单化来说，即事先就构建出一定数量的工作线程，当有任务的时候就提交任务给构建好的工作线程去执行，当任务数超过总的工作线程时则将任务暂时存放在任务队列中，等待有空闲的工作线程时，再去执行任务；根据上述方式，我们可以自定义一个线程池：

    //自定义的线程池
class MyThreadPool {
    //最大线程数
    public int thread_max;
    //任务队列
    public BlockingQueue<Runnable> taskQueue;
    //工作线程存放数组
    public WorkThread[] threads;

    //默认值
    public static final int THREAD_MAX = 3;
    public static final int TASK_MAX = 5;


    public MyThreadPool() {
        this(3, 5);
    }

    public MyThreadPool(int thread_num, int task_num) {
        if (thread_num <= 0) {
            this.thread_max = THREAD_MAX;
        } else {
            this.thread_max = thread_num;
        }
        if (task_num <= 0) {
            task_num = TASK_MAX;
        }
        //构建任务队列,任务队列的创建要在工作线程开启之前，否则就会抛出异常
        taskQueue = new ArrayBlockingQueue<Runnable>(task_num);
        //构建对应数量的工作线程
        threads = new WorkThread[thread_max];
        for (int i = 0; i < thread_num; i++) {
            threads[i] = new WorkThread();
            threads[i].start();
        }

    }

    public void execute(Runnable task) throws InterruptedException {
        taskQueue.put(task);
    }

    public void destroy() {
        System.out.println("now will stop all work Thread......");
        for (int i = 0; i < this.thread_max; i++) {
            threads[i].stopWorkThread();
            threads[i] = null;
        }
        taskQueue.clear();
    }

    class WorkThread extends Thread {
        @Override
        public void run() {
            Runnable runnable = null;
            try {
                //终止工作线程的条件
                while (!isInterrupted()) {
                    if (taskQueue != null) {
                        runnable = taskQueue.take();
                        if (runnable != null) {
                            System.out.println(getId() + ", will start runable : " + runnable);
                            runnable.run();
                        }
                    }
                    runnable = null;
                }
            } catch (Exception e) {
            }
        }

        //用来停止工作线程
        public void stopWorkThread() {
            interrupt();
        }
    }
}

//使用自定义的线程池完成工作
class UseMyThreadPool {
    // 任务类
    static class MyTask implements Runnable {
        private String name;
        private Random r = new Random();

        public MyTask(String name) {
            this.name = name;
        }

        // 执行任务
        @Override
        public void run() {
            try {
                Thread.sleep(r.nextInt(100)+200);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getId()+" sleep InterruptedException:"
                        +Thread.currentThread().isInterrupted());
            }
            System.out.println("任务 " + name + " 完成");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThreadPool threadPool = new MyThreadPool();
        threadPool.execute(new MyTask("11111"));
        threadPool.execute(new MyTask("22222"));
        threadPool.execute(new MyTask("33333"));
        threadPool.execute(new MyTask("44444"));
        threadPool.execute(new MyTask("55555"));
        threadPool.execute(new MyTask("66666"));
        Thread.sleep(50000);
        threadPool.destroy();
    }
}

    关于自定义的线程池，最核心的内容就是：

    1. 初始化一个工作线程数组，用来存放工作线程
    2. 构建一个阻塞队列，用来存放需要执行的任务

3. 线程池中的类关系

  • Executor
    • 它是一个接口类，是Executor框架的基础，他将任务的提交和任务的执行分离开来
    • 他其中只有一个方法：void execute(Runnable var1);
  • ExecutorService
    • ExecutorService接口继承了Executor，并在这个基础上做了方法拓展，比如shutdown、shutdownNow、submit方法等，该接口类可以说是真正的线程池的接口
  • AbstractExecutorService
    • AbstractExecutorService抽象类实现了ExecutorService接口中的大部分方法
  • ThreadPoolExecutor
    • ThreadPoolExecutor是线程池的核心实现类，继承了AbstractExecutorService，它是用来执行被提交的任务的
  • ScheduledExecutorService
    • ScheduledExecutorService接口继承了ExecutorService，提供了带周期执行功能的ExecutorService
  • ScheduledThreadPoolExecutor
    • ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令

4. ThreadPoolExecutor构造函数中各个参数的意义

  • public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)
    1. corePoolSize
      • 线程池中的核心线程数
      • 如果执行了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。
    2. maximumPoolSize
      • 线程池中允许的最大线程数
    3. keepAliveTime
      • 线程空闲时的存活时间，即当线程没有任务执行时，继续存活的时间。
      • 默认情况下，该参数只在线程数大于corePoolSize时才有用，即假设核心线程数是5，最大线程数是10，那么当时间到后，只会杀掉超过核心线程数的5个线程
    4. unit
      • keepAliveTime的时间单位
    5. workQueue
      • 存放任务的阻塞队列
      • 当线程池中的线程数超过它的corePoolSize的时候，线程会进入阻塞队列进行阻塞等待。通过workQueue，线程池实现了阻塞功能
      • 一般来说，我们应该尽量使用有界队列，具体原因见下文线程池工作流程解析
    6. threadFactory
      • 创建线程的工厂，通过自定义的线程工厂可以给每个新建的线程设置一个具有识别度的线程名
      • 当然还可以更加自由的对线程做更多的设置，比如设置所有的线程为守护线程
      • Executors静态工厂里默认的threadFactory，线程的命名规则是pool-数字-thread-数字。
    7. handler
      • 线程池的饱和策略
      • 当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：
        1. AbortPolicy：直接抛出异常，默认策略
        2. CallerRunsPolicy：用调用者所在的线程来执行任务
        3. DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务
        4. DiscardPolicy：直接丢弃任务
      • 当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务

5. ThreadPoolExecutor的工作流程解析

  • 线程池的流程：

    1. 如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）
    2. 如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue
    3. 如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务(此时线程数小于maximumPoolSize)
    4. 如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法
      在这里插入图片描述

  • workQueue为什么需要尽量使用有界队列

    1. 当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize。
    2. 由于1，使用无界队列时maximumPoolSize将是一个无效参数。
    3. 由于1和2，使用无界队列时keepAliveTime将是一个无效参数。
    4. 更重要的，使用无界queue可能会耗尽系统资源，有界队列则有助于防止资源耗尽，同时即使使用有界队列，也要尽量控制队列的大小在一个合适的范围。

6. 线程池中任务的提交

  • 使用线程池提交任务有两个方法

    1. public void execute(Runnable command)

      • execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。

    2. public <T> Future<T> submit(Runnable task, T result)

      public <T> Future<T> submit(Callable<T> task)

      public <T> Future<T> submit(Callable<T> task)

      • submit()方法用于提交需要返回值的任务
      • 线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功
      • 我们还可以通过future对象的get()方法来获取返回值
      • 需要注意的是：get()方法会阻塞当前线程直到任务完成;而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

7. 关闭线程池

  • 关闭线程池有两个方法
    1. public void shutdown()
    2. public List<Runnable> shutdownNow()
  • 工作原理
    • 它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止
  • 两种方法的区别
    • shutdownNow()方法会首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表
    • shutdown()方法只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程
  • 判断线程池是否结束有两个方法
    • public boolean isShutdown()
      • 只要调用了上面两个方法中的任何一个方法，isShutdown()方法就会返回TRUE
    • public boolean isTerminated()
      • 只有当所有的任务都已关闭后，才表示线程池关闭成功，此时调用isTerminated()方法才会返回TRUE

8. 合理的配置线程池

  • 要想合理地配置线程池，就必须首先分析任务特性，可以从一下几个角度来分析
    1. 任务的性质：
      • CPU密集型任务 ： 纯计算任务
      • IO密集型任务 ：涉及到如网络连接操作、读取磁盘等频繁使用IO的任务
      • 混合型任务
    2. 任务的优先级：高、中和低
    3. 任务的执行时间：长、中和短
    4. 任务的依赖性：是否依赖其他系统资源，如数据库连接
  • 根据任务特性来配置线程池的数量（该数量是最大线程数---->maximumPoolSize）
    • CPU密集型任务
      • 应该配置尽可能少的线程，线程数 = 机器的CPU核心数 + 1
        • 为什么 +1：避免出现页缺失，造成CPU资源浪费
          • 即数据存储有可能一部分存储在内存中，一部分存放在虚拟内存(即分出一部分磁盘空间作为内存空间进行存放数据，该段空间就叫做虚拟内存)中，当某一个任务需要的数据是存放在虚拟内存中的时候，那么就需要CPU将虚拟内存中的数据先拷贝到内存中来再给当前任务使用，而从磁盘中读写数据速度是远远不如内存中读写的，那么当前任务线程就会由于等待数据的拷贝而被CPU暂时“挂起”，等到数据拷贝完成，再被"唤醒"继续执行，该种状态就是所谓的页缺失；而配置线程数+1，就是为了保证在多个线程运行时，有线程进入页缺失状态时，能够有另外的线程直接先开始运行，从而保证充分的利用CPU的资源。
      • 原因：此时CPU是保持一直运行的状态，如果在这种情况下开启很多线程，那么就徒增了上下文切换的时间，反而得不偿失
    • IO密集型任务
      • 应配置尽可能多的线程， 线程数 = 机器的CPU核心数 * 2
      • 原因：此时CPU并不是一直在执行任务，读取网络数据、读取磁盘的速度是有限的，在获取数据的过程中，相关任务线程就是处在“挂起”状态的，所以可以多做一些上下文切换的动作，从而充分利用CPU资源
    • 混合型任务
      • 混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。如果这两个任务执行时间相差太大，则没必要进行分解
    • 可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数
  • 存在任务优先级的线程池配置
    • 可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先执行
  • 任务执行时间不同的线程池配置
    • 可以交给不同规模的线程池来处理，或者可以使用优先级队列，让执行时间短的任务先执行。

9. 代码示例

class UseThreadPool {
    static class callWork implements Runnable {
        public String name;

        public callWork(String str) {
            name = str;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "," + this.name);
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = new ThreadPoolExecutor(1, 4, 5, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(2),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        for (int i = 0; i < 20; i++) {
            callWork callWorker = new callWork("callWork-" + i);
            pool.execute(callWorker);
        }

        pool.shutdown();
    }
}
super_marie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发－线程池和阻塞队列
10-18
并发－线程池和阻塞队列 并发－线程池和阻塞队列 并发－线程池和阻塞队列
线程池（一）：阻塞队列
bugmiao的博客
12-08 2868
线程 线程的状态 Java线程在运行的声明周期中可能会处于6种不同的状态，这6种线程状态分别为如下所示。 • New：新创建状态。线程被创建，还没有调用 start 方法，在线程运行之前还有一些基础工作要做。 • Runnable：可运行状态。一旦调用start方法，线程就处于Runnable状态。一个可运行的线程可能正在 运行也可能没有运行，这取决于操作系统给线程提供运行的时间。 • Blocked：阻塞状态。表示线程被锁阻塞，它暂时不活动。 • Waiting：等待状态。线程暂时不活动，并且不运行任何代
2019年Java大厂面试题讲解（周阳） 之线程池（Java中有哪些方法获取多线程）
轻狂书生FS的博客
05-13 2285
前言 获取多线程的方法，我们都知道有三种，还有一种是实现Callable接口 实现Runnable接口 实现Callable接口 实例化Thread类 使用线程池获取 Callable接口 Callable接口，是一种让线程执行完成后，能够返回结果的 在说到Callable接口的时候，我们不得不提到Runnable接口 /** * 实现Runnable接口 */ class MyThread implements Runnable { @Override public void r
@阻塞队列和线程池
weixin_49329785的博客
06-03 1403
阻塞队列 当队列是空的，从队列中获取元素的操作将会被阻塞 当队列是满的，从队列中添加元素的操作将会被阻塞 试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素 试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增 常见的BlockingQueue 1.ArrayBlockingQueue(常用) 2.LinkedBlockingQueue(常用) 3.DelayQueue 4...
什么是阻塞队列？
Junudam的博客
07-28 3459
什么是阻塞队列？ 阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。 阻塞队列提供了四种处理方法: 方法\处理方式 抛出异常 返回特殊值 一直阻塞 超时退出 插入方法 add(e) offer(e) pu.
并发－线程池和阻塞队列.pdf
10-17
讲述线程池原理，线程池使用场景和注意事项，手动创建线程池方法，注意事项，阻塞队列的相关知识
day19_阻塞队列、线程池、File类、递归.pdf
11-02
【正文】 本文主要讲解了Java中的阻塞队列、线程池以及File类的相关知识，并...以上内容涵盖了阻塞队列、线程池、File类和递归的基础知识，它们都是Java编程中不可或缺的部分，对于理解和编写高效的并发程序至关重要。
阻塞队列、线程池和四大函数式接口.md
05-08
java进阶部分
libthread_new.rar_linux 线程池_linux任务队列_线程池
09-23
实现了一个线程池。...在队列和线程池之间创建了一个中间夹层，以提高可移植性。当任务来时，先压入队列，然后唤醒线程执行操作。线程完成任务后，再去队列查询，如果有任务就去执行，没有则阻塞，等待
java线程池饱和策略_java并发：线程池、饱和策略、定制、扩展
weixin_32965939的博客
02-13 475
一、序言当我们需要使用线程的时候，我们可以新建一个线程，然后显式调用线程的start()方法，这样实现起来非常简便，但在某些场景下存在缺陷：如果需要同时执行多个任务(即并发的线程数量很多)，频繁地创建线程会降低系统的效率，因为创建和销毁线程均需要一定的时间。线程池可以使线程得到复用，所谓线程复用就是线程在执行完一个任务后并不被销毁，该线程可以继续执行其他的任务。java.lang.concurre...
10.阻塞队列和线程池
汤坤
05-13 1650
阻塞队列通常使用在生产者消费者设计模式当中,生产者不用关心生成的产品由哪个消费者来执行,只需将生产的产品放入队列中,消费者直接从队列中取出产品使用,达到了生产者与消费者之间解耦的目的和性能均衡问题.因为线程的创建、执行和销毁都是需要耗费时间和资源的,所以通过线程池来避免线程的重复创建和销毁。线程池的创建 (各个参数的含义)线程池是用来管理线程的.
阻塞队列&线程池
Android小白
05-15 1184
前言 阻塞队列是线程池的基础。两者都是面试热点，尤其是线程池。所以我特地花时间学习了一下这方面的知识，并做记录。 一.阻塞队列 这个其实用的非常多。安卓里面 Handler机制的MessageQueue，我认为就是一个阻塞队列。 ...
线程池阻塞
weixin_43810802的博客
03-03 997
线程池的阻塞问题线程池的知识 问题 今天碰到一个有意思的问题，我把它抽取出来： package thread_pool; import java.util.concurrent.*; public class TestThreadPool { public static void main(String[] args) { ExecutorService threadP...
阻塞线程池
06-11 2841
相关文档内容： 排队 所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：     如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。    如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。    如果无法将请求加入
Java 并发编程--阻塞队列和线程池
sziitjin的博客
08-14 908
1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满。2）支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空。在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序整体处理数据的速度。在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。
多线程与高并发五:等待队列及Executor和线程池详解
qq_40230026的博客
07-21 2799
一:等待队列 关于创建线程池的好处这里就不介绍了,直接上干货.首先,要想弄明白线程池,先要认识一些队列,这是线程池的基础. 多线程容器,以后多考虑Queue,少考虑List，Set. 这里来一道面试题:Queue相比较list比较好的地方? 有对多线程比较友好的接口,有以下方法: offer:----相当于add，会有返回值，成功了返回ture poll:取数据并且remove掉 peek：取数据不remove掉 BlockingQueue在线程池里是经常出现的队列：它是阻塞队列.多了下面的阻塞方法. p
线程池常用的阻塞队列有哪些？
谢文峰的博客
06-25 7136
线程池常用的阻塞队列有哪些？ 文章目录线程池常用的阻塞队列有哪些？1.线程池的内部结构2.阻塞队列3.LinkedBlockingQueue4.SynchronousQueue5.DelayedWorkQueue6.参考 1.线程池的内部结构 线程池内部由四部分组成 第一部分是线程池管理器，主要负责管理线程池的创建、销毁、添加任务等管理操作。 第二部分是工作线程，它又分为核心工作线程和非核心工作线程。 第三部分是任务队列，作为一种缓冲机制，会将超过核心线程数的任务放到任务队列中，等待执行；由于
阻塞队列和线程池搭配用
最新发布
03-14
阻塞队列和线程池的搭配使用是为了提高程序的性能和效率，通过避免不必要的线程创建和销毁，减少资源消耗。阻塞队列在线程池中起到任务缓存和通信的作用，它允许生产者（添加任务的线程）和消费者（执行任务的工作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值