【项目实践02】【优先级阻塞队列】

已于 2024-03-26 09:54:15 修改
阅读量418 收藏 9
点赞数 8
分类专栏： 项目实践 文章标签： java spring boot
于 2024-02-01 15:06:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36882793/article/details/135891830
版权

文章目录

一、前言

本系列用来记录一些在实际项目中的小东西，并记录在过程中想到一些小东西，因为是随笔记录，所以内容不会过于详细。

二、项目背景

项目存在一个功能：对PDF文件进行压缩，且要求PDF 每页大小小于400KB。由于无法判断PDF 每页的大小，所以项目实现方案是将PDF 每页读取后转成图片再进行压缩到合适大小，最后将压缩后的图片再重新生成为 PDF。

在一通实现后，上述功能实现后便直接上线，但是上线后暴露出如下问题：

  • 对于多页数 PDF 的压缩效率太低：由于无法判定PDF每页是否满足大小，所以只能将PDF每页都进行 转图片、压缩、转PDF的操作。对于客户动辄50+页数的PDF，处理效率太低。并且由于存在压缩超时的判定限制，大页数PDF极有可能被判定为压缩超时。

为了解决上述问题，准备开启多线程以页为维度进行压缩，提高多页数PDF的解析效率。但经过测试，上述的PDF处理过程极其耗费资源,本地在测试时直接OOM,因此也要控制并发量。

三、实现方案

基础实现依托于下面的工具类，调用 ImgToPdfUtils#compressPdf 方法可完成压缩功能。

package com.kingfish.springcommondemo.docs;

import com.google.common.collect.Lists;
import com.itextpdf.text.Document;
import com.itextpdf.text.Image;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.pdf.*;
import com.kingfish.common.api.CommonBizException;
import com.kingfish.common.utils.ThreadUtil;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
 * @Author : kingfish
 * @Email : kingfishx@163.com
 * @Date : 2024/1/28 15:16
 * @Desc :
 */
@Slf4j
public class PdfCompressUtils {


    /**
     * 每页最大
     */
    private static final int SINGLE_PDF_MAX_SIZE = 350 * 1000;

    /**
     * PDF 压缩
     *
     * @param pdfBytes
     * @return
     */
    public static byte[] syncCompressPdf(byte[] pdfBytes) throws Exception {
        final List<byte[]> imageBytesList = pdf2Images(pdfBytes);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Document doc = new Document();
        PdfCopy pdfCopy = new PdfCopy(doc, bos);
        pdfCopy.setFullCompression();
        pdfCopy.setCompressionLevel(PdfStream.BEST_COMPRESSION);
        doc.open();

        imageBytesList.forEach(imageBytes ->
                copyFileToPdf(pdfCopy, compressImage2Pdf(imageBytes, SINGLE_PDF_MAX_SIZE)));

        pdfCopy.close();
        doc.close();
        return bos.toByteArray();
    }

    /**
     * PDF 压缩
     *
     * @param pdfBytes
     * @return
     */
    public static byte[] asyncCompressPdf(byte[] pdfBytes) throws Exception {
        final List<byte[]> imageBytesList = pdf2Images(pdfBytes);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Document doc = new Document();
        PdfCopy pdfCopy = new PdfCopy(doc, bos);
        pdfCopy.setFullCompression();
        pdfCopy.setCompressionLevel(PdfStream.BEST_COMPRESSION);
        doc.open();

        final List<CompletableFuture<byte[]>> completableFutures =
                imageBytesList
                        .stream()
                        .map(imageBytes ->
                                CompletableFuture.supplyAsync(() ->
                                                compressImage2Pdf(imageBytes, SINGLE_PDF_MAX_SIZE),
                                        ThreadUtil.getIoPool()))
                        .collect(Collectors.toList());

        CompletableFuture.allOf(
                        completableFutures.toArray(new CompletableFuture[0]))
                .join();

        completableFutures.stream()
                .filter(Objects::nonNull)
                .map(CompletableFuture::join)
                .forEach(pageBytes -> copyFileToPdf(pdfCopy, pdfBytes));

        pdfCopy.close();
        doc.close();
        return bos.toByteArray();
    }


    /**
     * pdf 转图片
     *
     * @param pdfBytes
     * @return
     */
    private static List<byte[]> pdf2Images(byte[] pdfBytes) {
        List<byte[]> results = Lists.newArrayList();
        try (PDDocument document = PDDocument.load(pdfBytes)) {
            PDFRenderer renderer = new PDFRenderer(document);
            for (int i = 0; i < document.getNumberOfPages(); ++i) {
                // DPI 越大，清晰度越高
                BufferedImage bufferedImage = renderer.renderImageWithDPI(i, 300);
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                ImageIO.write(bufferedImage, "jpeg", out);
                results.add(out.toByteArray());
            }
        } catch (IOException e) {
            log.error("pdf转图片出错", e);
        }
        return results;
    }

    /**
     * 生成PDF
     *
     * @param pdfCopy
     * @param pdfBytes
     * @throws IOException
     * @throws BadPdfFormatException
     */
    @SneakyThrows
    public static void copyFileToPdf(PdfCopy pdfCopy, byte[] pdfBytes) {
        PdfReader reader = new PdfReader(pdfBytes);
        int totalPages = reader.getNumberOfPages();
        for (int j = 1; j <= totalPages; j++) {
            pdfCopy.addPage(pdfCopy.getImportedPage(reader, j));
        }
        reader.close();
    }

    /**
     * 图片压缩
     *
     * @param imageBytes
     * @param maxSize
     * @return
     */
    public static byte[] compressImage2Pdf(byte[] imageBytes, int maxSize) {
        try (ByteArrayOutputStream resultBos = new ByteArrayOutputStream()) {
            Document document;
            if (imageBytes.length > maxSize) {
                // 递归压缩
                imageBytes = compressImageCycle(imageBytes, maxSize, 0);
            }

            // 绘制图片转为 PDF
            Image image = Image.getInstance(imageBytes);
            image.setCompressionLevel(PdfStream.BEST_COMPRESSION);
            float scaledWidth = image.getScaledWidth();
            float scaledHeight = image.getScaledHeight();
            if (scaledWidth > scaledHeight) {
                image.scaleToFit(842.0F, 575.0F);
                document = new Document(PageSize.A4.rotate(), 0, 0, 0, 0);
            } else {
                image.scaleToFit(575.0F, 842.0F);
                document = new Document(PageSize.A4, 0, 0, 0, 0);
            }
            PdfWriter writer = PdfWriter.getInstance(document, resultBos);
            writer.setCompressionLevel(PdfStream.BEST_COMPRESSION);
            writer.setFullCompression();

            document.open();
            document.add(image);
            document.close();
            return resultBos.toByteArray();
        } catch (Exception exception) {
            throw new CommonBizException(exception);
        }
    }

    /**
     * @param bytes 原图片字节数组
     * @return
     */
    private static byte[] compressImageCycle(byte[] bytes, int maxSize, int cycle) throws IOException {

        double accuracy = getAccuracy(bytes.length / 1000);
        //计算宽高
        BufferedImage bim = ImageIO.read(new ByteArrayInputStream(bytes));
        int imgWidth = bim.getWidth();
        int imgHeight = bim.getHeight();
        int desWidth = new BigDecimal(imgWidth).multiply(new BigDecimal(accuracy)).intValue();
        int desHeight = new BigDecimal(imgHeight).multiply(new BigDecimal(accuracy)).intValue();
        // 构造一个类型为预定义图像类型之一的 BufferedImage
        BufferedImage tag = new BufferedImage(desWidth, desHeight, BufferedImage.TYPE_INT_RGB);
        // 这边是压缩的模式设置
        tag.getGraphics().drawImage(bim.getScaledInstance(desWidth, desHeight, java.awt.Image.SCALE_SMOOTH), 0, 0,
                null);
        //将图片按JPEG压缩，保存到out中
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(tag, "jpeg", baos);

        cycle++;
        int srcSize = baos.size();
        if (srcSize > maxSize && cycle < 6) {
//            log.info(srcSize / 1000 + "KB文件大于" + maxSize / 1000 + "KB，第" + (cycle + 1) + "次进行压缩");
            return compressImageCycle(baos.toByteArray(), maxSize, cycle);
        }
        return baos.toByteArray();
    }

    /**
     * 自动调节精度
     *
     * @param size 源图片大小
     * @return 图片压缩质量比
     */
    private static double getAccuracy(long size) {
        double accuracy;
        if (size < 900) {
            accuracy = 0.85;
        } else if (size < 2047) {
            accuracy = 0.6;
        } else if (size < 3275) {
            accuracy = 0.44;
        } else {
            accuracy = 0.4;
        }
        return accuracy;
    }
}

使用20个PDF 文件 模拟测试调用，方法如下：

public class PdfDemoMain {

    public static void main(String[] args) throws Exception {
        sync();
        async();
    }

    /**
     * 同步调用
     */
    private static void sync() {
        final File[] files = new File("C:\\Users\\Administrator\\Desktop\\compress\\压缩前").listFiles();
        FileUtil.del("C:\\Users\\Administrator\\Desktop\\compress\\压缩后\\");
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 模拟并发调用
        final CompletableFuture[] cfs = Arrays.stream(files)
                .map(file ->
                        CompletableFuture.runAsync(() -> {
                            try {
                                // 同步压缩
                                byte[] compressBytes = PdfCompressUtils.syncCompressPdf(FileUtil.readBytes(file));
                                FileUtil.writeBytes(compressBytes, "C:\\Users\\Administrator\\Desktop\\compress\\压缩后\\" + file.getName() + ".pdf");
                            } catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        })).toArray(CompletableFuture[]::new);
        CompletableFuture.allOf(cfs).join();
        stopWatch.stop();
        System.out.println("同步花费时长: " + stopWatch.getTotalTimeSeconds());
    }

    /**
     * 异步调用
     */
    private static void async() {
        final File[] files = new File("C:\\Users\\Administrator\\Desktop\\compress\\压缩前").listFiles();
        FileUtil.del("C:\\Users\\Administrator\\Desktop\\compress\\压缩后\\");
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 模拟并发调用
        final CompletableFuture[] cfs = Arrays.stream(files)
                .map(file ->
                        CompletableFuture.runAsync(() -> {
                            try {
                                // 异步压缩
                                byte[] compressBytes = PdfCompressUtils.asyncCompressPdf(FileUtil.readBytes(file));
                                FileUtil.writeBytes(compressBytes, "C:\\Users\\Administrator\\Desktop\\compress\\压缩后\\" + file.getName() + ".pdf");
                            } catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        })).toArray(CompletableFuture[]::new);
        CompletableFuture.allOf(cfs).join();

        stopWatch.stop();
        System.out.println("异步花费时长: " + stopWatch.getTotalTimeSeconds());
    }
}

测试结果如下：
在这里插入图片描述

可以看到效率具有非常明显的提升，但是需要注意的是：

  1. PdfCompressUtils 的异步方法并非是所有情况都适用。当观察机器的CPU，如果CPU本身已经接近满载，再使用异步方法可能并不会提升效率。
  2. PdfCompressUtils 压缩方法的目的是将PDF 每页大小压缩尽量接近400Kb，因此压缩后的PDF大小可能会变更大，因为原先一页可能只有20KB，压缩后可能变成了380KB。
  3. PdfCompressUtils 压缩过程中对于PDF 可能会存在多次压缩，因为无法把握合适的压缩系数。比如500KBPDF 压缩一次后可能是420KB，则需要再次压缩。

四、思路延伸

PdfCompressUtils 中提供的压缩功能个人感觉并非最优解，效率低且占用资源非常高，在本地测试的时候因为过高的并发度导致 OOM 的发生，因此还需要控制 PdfCompressUtils 方法请求的并发度，否则可能会导致OOM的发送。而并发度的控制有两个方面：

  1. 异步压缩开启的线程数量：这个可以直接通过 ThreadUtil.getIoPool() 的线程池来控制。
  2. 服务接口被请求的并发控制：这个首先想到的就是队列，对于有优先级要求的情况下，单节点的情况下可以使用java.util.concurrent.PriorityBlockingQueue，而多节点则可以使用 Redisson 提供的 PriorityBlockingQueue。

1. 优先级队列

1.1 concurrent 包下的 PriorityBlockingQueue

下面以 java.util.concurrent.PriorityBlockingQueue 为例，在 PdfCompressUtils 中增加如下内容：


@Slf4j
public class PdfCompressUtils {

	...
	
	/**
     * 文件队列
     */
   private static final PriorityBlockingQueue<PriorityFile> FILE_QUEUES = Queues.newPriorityBlockingQueue();
	
   static {
   		// 可以通过线程池的线程数量来控制队列消费的并发度，这里使用单线程是为了方便测试
        final ExecutorService executorService =
                Executors.newSingleThreadExecutor();
        executorService.submit(PdfCompressUtils::runCompressTask);
    }

    private static void runCompressTask() {
        while (true) {
            try {
            	// 睡眠10s 也是为了方便测试，让所有PDF都入队后再出队
                Thread.sleep(10000);
                // 从队列中取出
                final PriorityFile priorityFile = FILE_QUEUES.take();
                log.info("文件 {} 优先级为 {} 从队列中取出", priorityFile.getFile().getName(), priorityFile.getPriority());
                // 压缩
                final byte[] results = asyncCompressPdf(FileUtil.readBytes(priorityFile.getFile()));
                // 压缩完成回调
                priorityFile.getCallback().accept(results);
            } catch (Exception e) {
                // TODO : 文件压缩失败之后的处理
            }
        }
    }

    /**
     * PDF 压缩
     * @param file 要压缩的PDF
     * @param priority 优先级，越大优先级越高
     * @param callback 压缩回调，因为附件的优先级可能比较低导致一直没有压缩，因此使用回调的方式，当附件压缩完成时调用 callback 方法
     * @throws Exception
     */
    public static void asyncCompressPdf(File file, int priority, Consumer<byte[]> callback) throws Exception {
        log.info("文件 {} 优先级为 {} 投递到队列", file.getName(), priority);
        FILE_QUEUES.offer(new PriorityFile(file, priority, callback));
    }

    /**
     * 优先级文件
     */
    @Getter
    static class PriorityFile implements Comparable<PriorityFile> {

        /**
         * 文件
         */
        private File file;

        /**
         * 优先级
         */
        private int priority;

        /**
         * 结果回调
         */
        private Consumer<byte[]> callback;

        public PriorityFile(File file, int priority, Consumer<byte[]> callback) {
            this.file = file;
            this.priority = priority;
            this.callback = callback;
        }

        @Override
        public int compareTo(PriorityFile o) {
            return o.getPriority() - this.priority;
        }
    }

	...
	
}

可以看到压缩结果是按照优先级的顺序压缩的
在这里插入图片描述

总结：

  1. 通过静态代码块中的线程池来控制压缩的并发度，防止OOM
  2. 通过FILE_QUEUES 来控制压缩的优先级。
  3. 这里其实存在一个问题，当PDF入队后，服务宕机重启，队列中就没有该PDF记录了，解决方式可以是在当PDF入队后将PDF记录到Redis 或数据库中，当压缩成功后再移除，每次服务启动时加载Redis或数据库中的PDF压缩记录即可。

1.2 Redisson 的优先级阻塞队列

如果要使用 Redisson 的 优先级阻塞队列，则进行如下改造：


@Slf4j
public class PdfCompressUtils {

	...
	
 	private static RPriorityBlockingQueue<PriorityFile> FILE_QUEUES = null;

    private static RedissonClient REDISSON_CLIENT = null;

    static {

        Config config = new Config();
        config.useSingleServer()
                .setTimeout(1000000)
                .setDatabase(0)
                .setAddress("redis://127.0.0.1:6379");

        REDISSON_CLIENT = Redisson.create(config);
        FILE_QUEUES = REDISSON_CLIENT.getPriorityBlockingQueue("FILE_QUEUE");
		// 可以通过线程池的线程数量来控制队列消费的并发度，这里使用单线程是为了方便测试
        final ExecutorService executorService =
                Executors.newSingleThreadExecutor();

        executorService.submit(PdfCompressUtils::runCompressTask);

    }

    private static void runCompressTask() {
        while (true) {
            try {
            	// 睡眠10s 也是为了方便测试，让所有PDF都入队后再出队
                Thread.sleep(10000);
                final PriorityFile priorityFile = FILE_QUEUES.take();
                final File file = priorityFile.getFile();
                log.info("文件 {} 优先级为 {} 从队列中取出", file.getName(), priorityFile.getPriority());
                final byte[] results = asyncCompressPdf(FileUtil.readBytes(file));
                // 因为队列内容需要序列化到Redis中，所以无法使用回调函数，因此结果处理直接在这里处理
                FileUtil.writeBytes(results, "C:\\Users\\Administrator\\Desktop\\compress\\压缩后\\" + file.getName() + ".pdf");
                log.info("文件 {} 压缩完成", file.getName());
            } catch (Exception e) {
                // TODO : 文件压缩失败之后的处理
                log.info("文件压缩失败", e);
            }
        }
    }

  /**
     * PDF 压缩
     *
     * @param file
     * @param priority
     * @throws Exception
     */
    public static void asyncCompressPdf(File file, int priority) throws Exception {
        log.info("文件 {} 优先级为 {} 投递到队列", file.getName(), priority);
        FILE_QUEUES.offer(new PriorityFile(file, priority));
    }

  /**
     * 优先级文件
     */
    @Getter
    static class PriorityFile implements Comparable<PriorityFile>, Serializable {

        /**
         * 文件
         */
        private File file;

        /**
         * 优先级
         */
        private int priority;

        public PriorityFile() {
        }

        public PriorityFile(File file, int priority) {
            this.file = file;
            this.priority = priority;
        }

        @Override
        public int compareTo(PriorityFile o) {
            return o.getPriority() - this.priority;
        }
    }
    
	...
	
}

总结：

  1. 如果真的要使用，Redis 中建议保存的是文件上传到 OSS的文件地址或者数据库中Id，而不是直接保存 File 或 byte[]

  2. Redisson 的优先级阻塞队列使用的并不是 sorted set 做数据结构, 而是使用 list 结构。这一点可以在元素入队时看到，如下：

    
    @Override
    public boolean offer(V e) {
        return add(e);
    }
    
	@Override
    public boolean add(V value) {
        lock.lock();
        
        try {
            checkComparator();
    		// 二分查找，根据优先级确定当前元素入队的位置
            BinarySearchResult<V> res = binarySearch(value, codec);
            int index = 0;
            if (res.getIndex() < 0) {
                index = -(res.getIndex() + 1);
            } else {
                index = res.getIndex() + 1;
            }
             // lua 语句保证并发性在队列指定位置插入元素
            commandExecutor.evalWrite(getName(), RedisCommands.EVAL_VOID, 
               "local len = redis.call('llen', KEYS[1]);"
                + "if tonumber(ARGV[1]) < len then "
                    + "local pivot = redis.call('lindex', KEYS[1], ARGV[1]);"
                    + "redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);"
                    + "return;"
                + "end;"
                + "redis.call('rpush', KEYS[1], ARGV[2]);", 
                    Arrays.<Object>asList(getName()), 
                    index, encode(value));
            return true;
        } finally {
            lock.unlock();
        }
    }

2. jvisualvm 远程连接

jvisualvm 是 JDK 提供的监控 Java 程序的工具，当使用如下命令进行启动服务时，可以使用 jvisualvm 远程连接服务。（这块内容如有需要可详参
https://blog.csdn.net/zhou920786312/article/details/123572662）

java - jar -Djava.rmi.server.hostname=[serverIp] -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=[serverPort]  -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false demo.jar

这里注意两个变量：

  • serverIp 指的是当前服务部署的机器的ip地址
  • serverPort 指的是当前服务部署的机器暴露给外部的端口，jvisualvm 将通过此端口来远程连接。所以服务器需要开放serverPort 端口，否则也是无法连接。

以下为举例：

  1. 使用该命令启动服务, 其中 192.168.72.128 为服务器本地地址, 10081 为服务器暴露的端口

    [root@localhost app]# java -jar -Djava.rmi.server.hostname=192.168.72.128 -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=10081  -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false spring-simple-demo-1.0-SNAPSHOT.jar

  2. jvisualvm 建立连接 : 如下，直接建立连接，名称可以随便写

    在这里插入图片描述

    建立后再新增 JMX 连接，如下，连接内容填写服务器地址和暴露的端口。
    在这里插入图片描述

    连接后的效果如下：

    在这里插入图片描述

3. Jstack 高 CPU 排查

在使用上述 PDF 压缩时，会出现 CPU 使用率过高的情况，借此再总结下通过 jstack 命令排查 CPU使用率过高的情况，如下（这块内容如有需要详参 https://blog.csdn.net/weixin_44588186/article/details/124680586）：

  1. top ：通过 top 命令确定 服务器上 CPU 占用较高的进程是哪个， top 命令默认按照CPU 排序，可以铜鼓 top c 可以更清晰的看到进程信息，如下：
    在这里插入图片描述

  2. top -Hp pid ：确定好哪个进程 CPU 占用高后，可以通过 top -Hp pid 命令查看指定进程的每个线程的 CPU 占用情况。需要注意的是 top -Hp pid 中的 pid 指的是第一步中确定的进程的pid，而 命令输出中的 pid 则是指的进程中的 线程id。

    如下图中 top -Hp 2150 , 这里的 2150 指的是进程id，而输出中CPU 占用最高的 PID 为 2183，这个PID 为 线程id。

    在这里插入图片描述

  3. jstack pid : 通过 jstack pid 可以查看线程的具体信息( 可以通过 jstack pid >/tmp/log.txt 命令将内容输出到文件)。但我在本地测试的时候输出如下信息，无法输出正常数据，但所幸服务本身日志输出了对应内容 （因此次问题这里不做深究）。
    在这里插入图片描述

    jstack 命令正常输出线程信息如下:
    在这里插入图片描述

  4. 分析堆栈信息 ：将 top -Hp pid 记录下来的pid 转为十六进制，去 jstack日志文件中找，可以找到对应线程的代码，从而修改代码。
    如 上面通过 top -Hp 2150 命令确定 pid 为 2183 的线程CPU占用较高，所以将 2183 转为十六进制为887，在 jstack 的日志中搜索 887 ，便可以根据搜索结果可以确定问题代码
    在这里插入图片描述

五、参考内容

https://blog.csdn.net/zhou920786312/article/details/123572662
https://blog.csdn.net/weixin_44588186/article/details/124680586
https://zhuanlan.zhihu.com/p/657006095

猫吻鱼
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Redisson之几种分布式队列
湖人•总冠军
03-28 1万+
前言： 消息队列很好理解，顾明思议就是排队执行。Redisson 队列类似实现Java接口，例如Queue和BlockingQueue基于Redisson Api 来处理一些复杂的业务逻辑。 1.Queue Redisson中的RQueue对象实现了java.util.Queue接口。队列用于首先从最旧的元素开始处理元素的情况（也称为“先进先出”或FIFO）。与普通Java一样，...
五 ： PriorityBlockingQueue 优先级阻塞队列
stafen1的博客
04-28 1万+
一 ：优先级阻塞队列 PriorityBlockingQueue 图中可以看出， 该实现类共有四个 ， 第一个和第二个分别调用了第三个构造函数 ， 如果用户有指定参数，则将指定参数值传入，如果没有，则使用默认值初始化属性。 二 ： 该实现类的 put 方法 从图中可以看出 ，put方法里面调用了该类的offer方
java redis redisson 分布式锁 阻塞队列(BlockingQueue) 线程池 的使用
钓瞄的鱼的博客
12-30 8679
@[TOC](java redis redisson 分布式锁 阻塞队列(BlockingQueue) 线程池 的使用) 一、场景 用户付款成功->上传到第三方订单系统 订单付款成功 -> 添加到阻塞队列 -> 触发上传接口 -> 获取到锁（未获取到锁返回）-> 循环取出队列里的数据 -> 线程池 -> 多个线程处理 -> 处理完队列里面所有数据释放锁 -> 上传完成 二、代码实现 redisson工具类 //redi
Redis实现延迟队列
m0_62458145的博客
01-12 1429
在上一篇文章Java中的redis介绍以及运用场景-CSDN博客中说到redis不仅仅可以用作缓存,可以用作分布式锁 由于redis高效的数据结构,redis可以用来做消息队列使用,以下就是关于怎么用redis来作为延迟队列的说明定时任务：有固定周期的，有明确的触发时间延迟队列：没有固定的开始时间，它常常是由一个事件触发的，而在这个事件触发之后的一段时间内触发另一个事件，任务可以立即执行，也可以延迟应用场景：场景一：订单下单之后30分钟后，如果用户没有付钱，则系统自动取消订单；
基于Redis实现消息队列的实践
凡夫编程
10-03 1319
Redis队列和MQ消息队列各有优势，Redis的最大特点就是快，所以基于Redis的消息队列相比MQ消息队列而言，更适合实时处理，但是基于Redis的消息队列更易受服务器内存限制；而RocketMQ消息队列作为专业的消息中间件产品，功能更完善，更适合应用于比较复杂的业务场景，可以实现离线消息发送、消息可靠投递以及消息的安全性，但MQ消息队列的读写性能略低于Redis队列。在技术选型时，除了上述的因素外，还有一个需要注意：大多数系统都会引入Redis作为基础的缓存中间件使用，如果要选用RocketMQ的话，
Java多线程（五）之BlockingQueue深入分析
热门推荐
Vern的专栏
12-01 6万+
一、概述： BlockingQueue作为线程容器，可以为线程同步提供有力的保障。 二、BlockingQueue定义的常用方法 1.BlockingQueue定义的常用方法如下:   抛出异常 特殊值 阻塞 超时 插入 add(e) offer(e) put(e) offer(e, time, unit) 移除
os.rar_优先级 队列
09-24
进程调度是操作系统中的关键功能，它决定了进程在就绪队列中的排列顺序，以及何时将进程从阻塞状态转变为就绪状态。 优先级队列是一种特殊的数据结构，用于存储等待执行的进程，每个进程都有一个与之关联的优先级。...
WindowsFormsApplication22.rar_优先级队列
07-14
OS高优先级优先问题 C#制作带界面 可查看就绪队列阻塞队列 进程有多个状态
rabbitmq结合spring实现消息队列优先级的方法
08-31
本文将详细介绍如何在Java Spring框架中结合RabbitMQ实现消息队列的优先级功能。RabbitMQ是一款广泛使用的消息中间件，它与Spring的良好集成使得在Java应用中实现消息队列变得简单高效。在灾情预警等需要优先处理...
剖析Java中阻塞队列的实现原理及应用场景
09-03
这是一个无界的阻塞队列，元素按优先级出队。 4. **DelayQueue**：基于PriorityQueue，元素需要在指定的延迟时间后才能被获取。它也是无界的，只有在延迟时间到达时，消费者才能取出元素。 阻塞队列和非阻塞队列的...
【并发编程系列9】阻塞队列之PriorityBlockingQueue,DelayQueue原理分析
zwx900102的博客
07-12 1856
PriorityBlockingQueue,DelayQueue原理分析前言PriorityBlockingQueueDelayQueue 前言 前面我们介绍了ArrayBlockingQueue，LinkedBlockingQueue,LinkedBlockingDeque三种阻塞队列，今天继续介绍其他阻塞队列 PriorityBlockingQueue PriorityBlockingQueue是一个支持优先级的无界阻塞队列。默认情况下元素采取自然顺序 升序排列。也可以自定义类实现compareTo()
PriorityBlockingQueue使用
冻冰粉星的博客
11-26 1万+
priorityBlockingQueue是一个无界队列，它没有限制，在内存允许的情况下可以无限添加元素；它又是具有优先级的队列，是通过构造函数传入的对象来判断，传入的对象必须实现comparable接口。 首先创建一个person对象，里面有id name 两个属性，person实现了comparable接口，并重写compareTo方法 public class Person imple...
阻塞queue系列之PriorityBlockingQueue
Kincym的博客
12-21 5510
和ArrayBlockingQueue一样内部使用数组实现，插入和获取数据使用同一把锁。不同的是，不管有无指定长度，都会实现可以实现自动扩容；在构造函数需传入comparator,用于插入元素时继续排序，若没有传入comparator，则插入的元素必须实现Comparatable接口。构造函数 public PriorityBlockingQueue() { this(DEFAULT
优先级对列PriorityBlockingQueue
筚路蓝缕 以启山林
09-09 545
PriorityBlockingQueue里面存储的对象必须是实现Comparable接口。队列通过这个接口的compare方法确定对象的priority。  规则是：当前和其他对象比较，如果compare方法返回负数，那么在队列里面的优先级就比较搞。  下面的测试可以说明这个断言：  查看打印结果，比较take出来的Entity和left的entity，比较他们的priorit
并发之PriorityBlockingQueue简单使用
搬砖路上的博客
09-01 3784
PriorityBlockingQueue是一个支持优先级的无界阻塞队列，直到系统资源耗尽。默认情况下元素采用自然顺序升序排列。也可以自定义类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue时，指定构造参数Comparator来对元素进行排序。但需要注意的是不能保证同优先级元素的顺序。PriorityBlockingQueue也是基于最小二叉堆实现，使用基于CAS实现的自旋锁来控制队列的动态扩容，保证了扩容操作不会阻塞take操作的执行 实现类需要自.
Java-Lambda
最新发布
lizhiwei21的博客
07-21 332
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 567
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1184
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
rabbitmq 队列 优先级队列
08-10
因此，在使用优先级队列时需要权衡消息的优先级和处理性能，确保高优先级消息不会一直阻塞低优先级的消息。 优先级队列在某些场景下非常有用，例如处理紧急情况的消息、提高关键业务的处理效率等。通过合理设置和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫吻鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值