为知笔记
Java内存分析-Arthas
编辑
2024-03-06
实用工具
00

简介

官方文档 Arthas（阿尔萨斯）是阿里巴巴开源的一款Java诊断工具，用于实时检测、诊断Java应用程序的性能问题。它是一个命令行工具，提供了丰富的功能，包括查看类加载信息、方法执行耗时、线程堆栈、内存分析等。Arthas 的设计目标是在生产环境中实时诊断和解决Java应用程序的问题。 以下是 Arthas 的一些主要特点和功能：

  • 实时性： Arthas 可以在运行中的 Java 进程中实时进行诊断，无需重新启动应用。

  • 丰富的命令： 提供了众多的命令，涵盖了类加载、方法执行、线程、内存、GC 等多个方面。

  • 动态追踪： 支持实时动态追踪方法调用、线程堆栈等信息，方便定位问题。

  • 内存分析： 提供了 Heap Dump、Histogram、Classloader Stats 等命令，帮助进行内存分析。

  • 多种环境支持： 支持 Linux、Mac 和 Windows 操作系统，支持 HotSpot 和 OpenJ9 JVM。

  • 在线帮助： 提供了丰富的在线帮助，用户可以通过 help 命令查看每个命令的详细说明。

主要组件

主要有以下几大组件:

  • arthas-core.jar 是服务器端的启动入口类，调用 VirtualMachine#attach 到目标进程，并加载 arthas-agent.jar 作为 agent 包。

  • arthas-agent.jar 既可以使用 premain 方式（在目标进程启动之前，通过-agent参数静态指定），也可以通过 agentmain 方式（在进程启动之后attach上去）。arthas-agent会使用自定义的classloader(ArthasClassLoader)加载arthas-core.jar里面的Configure类以及ArthasBootstrap。 同时程序运行的时候会使用arthas-spy.jar。

  • arthas-spy.jar 里面只包含Spy类，目的是为了将Spy类使用BootstrapClassLoader来加载，从而使目标进程的java应用可以访问Spy类。通过ASM修改字节码，可以将Spy类的方法ON_BEFORE_METHOD， ON_RETURN_METHOD等编织到目标类里面。

  • arthas-client.jar 是客户端程序，用来连接arthas-core.jar启动的服务端代码，使用telnet方式。一般由arthas-boot.jar和as.sh来负责启动。

下载

官方下载地址

text
# 下载
curl -O https://arthas.aliyun.com/arthas-boot.jar
# 启动服务
java -jar arthas-boot.jar
# 查看帮助
help
阅读全文
Java编程式事务
编辑
2024-02-23
学习记录
00

前提

TransactionTemplate是Spring框架中的一个类，用于编程式地管理事务。它允许开发者在方法内定义事务范围，以确保在方法执行期间的数据库操作要么全部成功提交，要么全部回滚。TransactionTemplate提供了一种更灵活、更细粒度的事务控制方式，适用于各种场景。

为什么使用

在Spring Boot中，通常有两种事务管理的方式：声明式事务管理和编程式事务管理。声明式事务管理是通过注解或XML配置来定义事务行为，而编程式事务管理是通过代码来实现事务控制。

使用TransactionTemplate的好处在于，它使得事务管理更加灵活，可以更细粒度地控制事务的开始、提交和回滚。这对于某些特定需求的应用程序非常有用，例如需要在方法内部处理多个事务的嵌套情况。

使用

有返回值

java

public class TestService {

    @Autowired
    private TransactionTemplate transactionTemplate;

    public void performTransaction() {
        // 在这里执行事务性操作
        // 操作成功则事务提交，否则事务回滚
        transactionTemplate.execute(status -> {
            try {
                // 事务性操作
                // 如果操作成功，不抛出异常，事务将提交
            } catch (Exception e) {
                // 如果操作失败，抛出异常，事务将回滚
                status.setRollbackOnly();
            }
            return null;
        });
    }
}
阅读全文
Java中的拷贝
编辑
2024-02-21
学习记录
00

前提

在项目中有时候会遇到需要多个对象，但是他们的大部分属性的内容都是相同的，那么我们就可以使用克隆的方式来克隆对象，再单独修改不同部分的属性即可，精简多余的set代码。

简介

克隆是指创建一个对象的副本，使得新创建的对象在内容上与原始对象相同。在编程中，克隆是常用的技术之一，它具有以下几个重要用途和优势：

  • 复制对象：使用克隆可以创建一个与原始对象相同的新对象，包括对象的属性和状态。这样可以在不影响原始对象的情况下，对新对象进行修改、操作、传递等。这在某些场景下非常有用，可以避免重新创建和初始化一个对象。

  • 隔离性与保护：通过克隆，可以创建一个独立于原始对象的副本。这样，修改克隆对象时，不会影响到原始对象，从而实现了对象之间的隔离性。这对于多线程环境下的并发操作或者保护重要数据具有重要意义。

  • 性能优化：有时候，通过克隆对象可以提高程序的性能。在某些场景下，对象的创建和初始化过程可能较为耗时，如果需要多次使用这个对象，通过克隆原始对象可以避免重复的创建和初始化过程，从而提高程序的执行效率。

  • 原型模式：克隆在设计模式中有一个重要的角色，即原型模式。原型模式通过克隆来创建对象的实例，而不是使用传统的构造函数。这样可以提供更灵活的对象创建方式，并且避免了频繁的子类化。

在编程中，通常通过实现Cloneable接口和重写clone方法来实现对象的克隆。然而，需要注意的是克隆操作可能存在深拷贝和浅拷贝的区别，在使用时需要根据实际需求选择合适的克隆方式。

阅读全文
PDFToImage
编辑
2024-01-09
学习记录
00

依赖

xml
    <dependency>
      <groupId>org.apache.pdfbox</groupId>
      <artifactId>pdfbox</artifactId>
      <version>2.0.23</version>
    </dependency>

代码

java
//单页pdf
    public static String pdfToImage(String pdfBase64) throws IOException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64.getDecoder().decode(pdfBase64));
        PDDocument document = PDDocument.load(inputStream);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

        PDFRenderer renderer = new PDFRenderer(document);
        for(int i = 0; i < document.getNumberOfPages(); i++) {
            BufferedImage image = renderer.renderImageWithDPI(i, 300);
            ImageIO.write(image, "png", outputStream);
        }

        byte[] imageBytes = outputStream.toByteArray();
        String imageBase64 = Base64.getEncoder().encodeToString(imageBytes);

        document.close();
        return imageBase64;
    }

java
//多页pdf
    public static String[] pdfToImages(String pdfBase64) throws IOException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64.getDecoder().decode(pdfBase64));
        PDDocument document = PDDocument.load(inputStream);
        String imageBase64[] = new String[document.getNumberOfPages()];
        for(int i = 0; i < document.getNumberOfPages(); i++) {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            PDFRenderer renderer = new PDFRenderer(document);
            BufferedImage image = renderer.renderImageWithDPI(i, 300);
            ImageIO.write(image, "png", outputStream);
            byte[] imageBytes = outputStream.toByteArray();
            imageBase64[i] = Base64.getEncoder().encodeToString(imageBytes);
        }

        document.close();
        return imageBase64;
    }

java
//多线程的方式

    public static String[] pdfToImagesByMultiThreading(String pdfBase64) throws IOException, ExecutionException, InterruptedException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64.getDecoder().decode(pdfBase64));
        PDDocument document = PDDocument.load(inputStream);
        int pages = document.getNumberOfPages();
        int core=Runtime.getRuntime().availableProcessors();

        // 创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(core>pages?pages:core);

        List<CompletableFuture<String>> futures = new ArrayList<>();
        for (int i = 0; i < pages; i++) {
            final int pageIndex = i;
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                PDFRenderer renderer = new PDFRenderer(document);
                try {
                    BufferedImage image = renderer.renderImageWithDPI(pageIndex, 300);
                    ImageIO.write(image, "jpg", outputStream);
                } catch (IOException e) {
                    e.printStackTrace();
                    throw new BusinessException(ResultCodeEnum.ERR_0x1000.getCode(),"pdf转换出错"+e.getMessage());
                }
                byte[] imageBytes = outputStream.toByteArray();
                return Base64.getEncoder().encodeToString(imageBytes);


            }, executorService);

            futures.add(future);
        }
        // 等待所有任务完成并收集结果
        CompletableFuture<String>[] arrayFutures = futures.toArray(new CompletableFuture[0]);
        CompletableFuture.allOf(arrayFutures).join(); // 等待所有任务完成

        // 关闭线程池（在实际应用中考虑在服务停止时关闭）
        executorService.shutdown();
        document.close();

        // 等待所有任务完成并收集结果
        String[] imageBase64 = new String[pages];
        for (int i = 0; i < pages; i++) {
            imageBase64[i] = futures.get(i).get();
        }
        return imageBase64;
    }
阅读全文
ForkJoin
编辑
2023-12-25
学习记录
00

介绍

在JDK1.7中引入了一种新的Fork/Join线程池，它可以将一个大的任务拆分成多个小的任务并行执行并汇总执行结果。 Fork/Join采用的是分而治之的基本思想，分而治之就是将一个复杂的任务，按照规定的阈值划分成多个简单的小任务，然后将这些小任务的结果再进行汇总返回，得到最终的任务。

ForkJoinPool

ForkJoinPool是用于运行ForkJoinTasks的线程池，实现了Executor接口。 可以通过new ForkJoinPool()直接创建ForkJoinPool对象。

java
public ForkJoinPool() {
    this(Math.min(MAX_CAP, Runtime.getRuntime().availableProcessors()),
         defaultForkJoinWorkerThreadFactory, null, false);
}

public ForkJoinPool(int parallelism,
                        ForkJoinWorkerThreadFactory factory,
                        UncaughtExceptionHandler handler,
                        boolean asyncMode){
    this(checkParallelism(parallelism),
             checkFactory(factory),
             handler,
             asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
             "ForkJoinPool-" + nextPoolId() + "-worker-");
        checkPermission();
}

通过查看构造方法源码我们可以发现，在创建ForkJoinPool时，有以下4个参数：

  • parallelism：期望并发数。默认会使用Runtime.getRuntime().availableProcessors()的值
  • factory：创建ForkJoin工作线程的工厂，默认为defaultForkJoinWorkerThreadFactory
  • handler：执行任务时遇到不可恢复的错误时的处理程序，默认为null
  • asyncMode：工作线程获取任务使用FIFO模式还是LIFO模式，默认为LIFO
阅读全文