arthas源码刨析：arthas-core (2)

已于 2024-08-22 14:08:55 修改
阅读量205 收藏 8
点赞数 2
分类专栏： APM 文章标签： 开发语言 java
于 2024-08-22 13:51:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013257767/article/details/141398788
版权

文章目录


arthas-core的启动可以从上一篇做参考
在这里插入图片描述
参考 pom，即启动是调用的 Arthas 的 main 方法
在这里插入图片描述

attach JVM

JVM提供了 Java Attach 功能，能够让客户端与目标JVM进行通讯从而获取JVM运行时的数据，甚至可以通过Java Attach 加载自定义的代理工具，实现AOP、运行时class热更新等功能。

private void attachAgent(Configure configure) throws Exception {
        VirtualMachineDescriptor virtualMachineDescriptor = null;
        for (VirtualMachineDescriptor descriptor : VirtualMachine.list()) {
            String pid = descriptor.id();
            if (pid.equals(Long.toString(configure.getJavaPid()))) {
                virtualMachineDescriptor = descriptor;
                break;
            }
        }
        VirtualMachine virtualMachine = null;
        try {
            if (null == virtualMachineDescriptor) { // 使用 attach(String pid) 这种方式
                virtualMachine = VirtualMachine.attach("" + configure.getJavaPid());
            } else {
                virtualMachine = VirtualMachine.attach(virtualMachineDescriptor);
            }
           ……
        try {
             virtualMachine.loadAgent(arthasAgentPath,
                     configure.getArthasCore() + ";" + configure.toString());
         } catch (IOException e) {
    }

VirtualMachine.list() 相当于 jps 的功能：
在这里插入图片描述
attach是依靠这条代码：

virtualMachine = VirtualMachine.attach(virtualMachineDescriptor);

之后就是 loadAgent 并传入 core 和 configure 参数。

agent

agent 的代码很简单，只有2个类：
在这里插入图片描述
在这里插入图片描述

核心就是 AgentBootstrap ，对于 javaagent来说核心的启动入口：

    public static void premain(String args, Instrumentation inst) {
        main(args, inst);
    }

    public static void agentmain(String args, Instrumentation inst) {
        main(args, inst);
    }

神奇不，在 arthas-core 里传入的 -core 参数实际上是透传给agent的。整的很绕。 通过 bind 方法进行线程绑定，这一步和 arthas-boot 很像。

private static synchronized void main(String args, final Instrumentation inst) {
        // 尝试判断arthas是否已在运行，如果是的话，直接就退出
        try {
            Class.forName("java.arthas.SpyAPI"); // 加载不到会抛异常
            if (SpyAPI.isInited()) {
                ps.println("Arthas server already stared, skip attach.");
                ps.flush();
                return;
            }
        } catch (Throwable e) {
            // ignore
        }
        try {
            ps.println("Arthas server agent start...");
            // 传递的args参数分两个部分:arthasCoreJar路径和agentArgs, 分别是Agent的JAR包路径和期望传递到服务端的参数
            if (args == null) {
                args = "";
            }
            args = decodeArg(args);

            String arthasCoreJar;
            final String agentArgs;
            int index = args.indexOf(';');
            if (index != -1) {
                arthasCoreJar = args.substring(0, index);
                agentArgs = args.substring(index);
            } else {
                arthasCoreJar = "";
                agentArgs = args;
            }

            File arthasCoreJarFile = new File(arthasCoreJar);
            if (!arthasCoreJarFile.exists()) {
                ps.println("Can not find arthas-core jar file from args: " + arthasCoreJarFile);
                // try to find from arthas-agent.jar directory
                CodeSource codeSource = AgentBootstrap.class.getProtectionDomain().getCodeSource();
                if (codeSource != null) {
                    try {
                        File arthasAgentJarFile = new File(codeSource.getLocation().toURI().getSchemeSpecificPart());
                        arthasCoreJarFile = new File(arthasAgentJarFile.getParentFile(), ARTHAS_CORE_JAR);
                        if (!arthasCoreJarFile.exists()) {
                            ps.println("Can not find arthas-core jar file from agent jar directory: " + arthasAgentJarFile);
                        }
                    } catch (Throwable e) {
                        ps.println("Can not find arthas-core jar file from " + codeSource.getLocation());
                        e.printStackTrace(ps);
                    }
                }
            }
            if (!arthasCoreJarFile.exists()) {
                return;
            }

            /**
             * Use a dedicated thread to run the binding logic to prevent possible memory leak. #195
             */
            final ClassLoader agentLoader = getClassLoader(inst, arthasCoreJarFile);

            Thread bindingThread = new Thread() {
                @Override
                public void run() {
                    try {
                        bind(inst, agentLoader, agentArgs);
                    } catch (Throwable throwable) {
                        throwable.printStackTrace(ps);
                    }
                }
            };

            bindingThread.setName("arthas-binding-thread");
            bindingThread.start();
            bindingThread.join();
        } catch (Throwable t) {
            t.printStackTrace(ps);
            try {
                if (ps != System.err) {
                    ps.close();
                }
            } catch (Throwable tt) {
                // ignore
            }
            throw new RuntimeException(t);
        }
    }

ArthasBootstrap

bind 有调用了 core 里面 ArthasBootstrap.getInstance

private static void bind(Instrumentation inst, ClassLoader agentLoader, String args) throws Throwable {
        /**
         * <pre>
         * ArthasBootstrap bootstrap = ArthasBootstrap.getInstance(inst);
         * </pre>
         */
        Class<?> bootstrapClass = agentLoader.loadClass(ARTHAS_BOOTSTRAP);
        Object bootstrap = bootstrapClass.getMethod(GET_INSTANCE, Instrumentation.class, String.class).invoke(null, inst, args);
        boolean isBind = (Boolean) bootstrapClass.getMethod(IS_BIND).invoke(bootstrap);
        if (!isBind) {
            String errorMsg = "Arthas server port binding failed! Please check $HOME/logs/arthas/arthas.log for more details.";
            ps.println(errorMsg);
            throw new RuntimeException(errorMsg);
        }
        ps.println("Arthas server already bind.");
    }

而在 ArthasBootstrap中 我们用的 terminal，也就是 ShellServer， 就在 6. start agent server

private ArthasBootstrap(Instrumentation instrumentation, Map<String, String> args) throws Throwable {
        this.instrumentation = instrumentation;
        initFastjson();
        // 1. initSpy()
        initSpy();
        // 2. ArthasEnvironment
        initArthasEnvironment(args);
        String outputPathStr = configure.getOutputPath();
        if (outputPathStr == null) {
            outputPathStr = ArthasConstants.ARTHAS_OUTPUT;
        }
        outputPath = new File(outputPathStr);
        outputPath.mkdirs();
        // 3. init logger
        loggerContext = LogUtil.initLogger(arthasEnvironment);
        // 4. 增强ClassLoader
        enhanceClassLoader();
        // 5. init beans
        initBeans();
        // 6. start agent server
        bind(configure);
        executorService = Executors.newScheduledThreadPool(1, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                final Thread t = new Thread(r, "arthas-command-execute");
                t.setDaemon(true);
                return t;
            }
        });
        shutdown = new Thread("as-shutdown-hooker") {

            @Override
            public void run() {
                ArthasBootstrap.this.destroy();
            }
        };
        transformerManager = new TransformerManager(instrumentation);
        Runtime.getRuntime().addShutdownHook(shutdown);
    }

ShellServerImpl 的 bind 这段实现中，BuiltinCommandPack 完成了命名的声明并与 cli 输入内容进行命名绑定。并用 Netty 开启server。

 /**
     * Bootstrap arthas server
     *
     * @param configure 配置信息
     * @throws IOException 服务器启动失败
     */
    private void bind(Configure configure) throws Throwable {

        long start = System.currentTimeMillis();

        if (!isBindRef.compareAndSet(false, true)) {
            throw new IllegalStateException("already bind");
        }

        // init random port
        if (configure.getTelnetPort() != null && configure.getTelnetPort() == 0) {
            int newTelnetPort = SocketUtils.findAvailableTcpPort();
            configure.setTelnetPort(newTelnetPort);
            logger().info("generate random telnet port: " + newTelnetPort);
        }
        if (configure.getHttpPort() != null && configure.getHttpPort() == 0) {
            int newHttpPort = SocketUtils.findAvailableTcpPort();
            configure.setHttpPort(newHttpPort);
            logger().info("generate random http port: " + newHttpPort);
        }
        // try to find appName
        if (configure.getAppName() == null) {
            configure.setAppName(System.getProperty(ArthasConstants.PROJECT_NAME,
                    System.getProperty(ArthasConstants.SPRING_APPLICATION_NAME, null)));
        }

        try {
            if (configure.getTunnelServer() != null) {
                tunnelClient = new TunnelClient();
                tunnelClient.setAppName(configure.getAppName());
                tunnelClient.setId(configure.getAgentId());
                tunnelClient.setTunnelServerUrl(configure.getTunnelServer());
                tunnelClient.setVersion(ArthasBanner.version());
                ChannelFuture channelFuture = tunnelClient.start();
                channelFuture.await(10, TimeUnit.SECONDS);
            }
        } catch (Throwable t) {
            logger().error("start tunnel client error", t);
        }

        try {
            ShellServerOptions options = new ShellServerOptions()
                            .setInstrumentation(instrumentation)
                            .setPid(PidUtils.currentLongPid())
                            .setWelcomeMessage(ArthasBanner.welcome());
            if (configure.getSessionTimeout() != null) {
                options.setSessionTimeout(configure.getSessionTimeout() * 1000);
            }

            this.httpSessionManager = new HttpSessionManager();
            if (IPUtils.isAllZeroIP(configure.getIp()) && StringUtils.isBlank(configure.getPassword())) {
                // 当 listen 0.0.0.0 时，强制生成密码，防止被远程连接
                String errorMsg = "Listening on 0.0.0.0 is very dangerous! External users can connect to your machine! "
                        + "No password is currently configured. " + "Therefore, a default password is generated, "
                        + "and clients need to use the password to connect!";
                AnsiLog.error(errorMsg);
                configure.setPassword(StringUtils.randomString(64));
                AnsiLog.error("Generated arthas password: " + configure.getPassword());

                logger().error(errorMsg);
                logger().info("Generated arthas password: " + configure.getPassword());
            }

            this.securityAuthenticator = new SecurityAuthenticatorImpl(configure.getUsername(), configure.getPassword());

            shellServer = new ShellServerImpl(options);

            List<String> disabledCommands = new ArrayList<String>();
            if (configure.getDisabledCommands() != null) {
                String[] strings = StringUtils.tokenizeToStringArray(configure.getDisabledCommands(), ",");
                if (strings != null) {
                    disabledCommands.addAll(Arrays.asList(strings));
                }
            }
            BuiltinCommandPack builtinCommands = new BuiltinCommandPack(disabledCommands);
            List<CommandResolver> resolvers = new ArrayList<CommandResolver>();
            resolvers.add(builtinCommands);

            //worker group
            workerGroup = new NioEventLoopGroup(new DefaultThreadFactory("arthas-TermServer", true));

            // TODO: discover user provided command resolver
            if (configure.getTelnetPort() != null && configure.getTelnetPort() > 0) {
                logger().info("try to bind telnet server, host: {}, port: {}.", configure.getIp(), configure.getTelnetPort());
                shellServer.registerTermServer(new HttpTelnetTermServer(configure.getIp(), configure.getTelnetPort(),
                        options.getConnectionTimeout(), workerGroup, httpSessionManager));
            } else {
                logger().info("telnet port is {}, skip bind telnet server.", configure.getTelnetPort());
            }
            if (configure.getHttpPort() != null && configure.getHttpPort() > 0) {
                logger().info("try to bind http server, host: {}, port: {}.", configure.getIp(), configure.getHttpPort());
                shellServer.registerTermServer(new HttpTermServer(configure.getIp(), configure.getHttpPort(),
                        options.getConnectionTimeout(), workerGroup, httpSessionManager));
            } else {
                // listen local address in VM communication
                if (configure.getTunnelServer() != null) {
                    shellServer.registerTermServer(new HttpTermServer(configure.getIp(), configure.getHttpPort(),
                            options.getConnectionTimeout(), workerGroup, httpSessionManager));
                }
                logger().info("http port is {}, skip bind http server.", configure.getHttpPort());
            }

            for (CommandResolver resolver : resolvers) {
                shellServer.registerCommandResolver(resolver);
            }

            shellServer.listen(new BindHandler(isBindRef));
            if (!isBind()) {
                throw new IllegalStateException("Arthas failed to bind telnet or http port! Telnet port: "
                        + String.valueOf(configure.getTelnetPort()) + ", http port: "
                        + String.valueOf(configure.getHttpPort()));
            }

            //http api session manager
            sessionManager = new SessionManagerImpl(options, shellServer.getCommandManager(), shellServer.getJobController());
            //http api handler
            httpApiHandler = new HttpApiHandler(historyManager, sessionManager);

            logger().info("as-server listening on network={};telnet={};http={};timeout={};", configure.getIp(),
                    configure.getTelnetPort(), configure.getHttpPort(), options.getConnectionTimeout());

            // 异步回报启动次数
            if (configure.getStatUrl() != null) {
                logger().info("arthas stat url: {}", configure.getStatUrl());
            }
            UserStatUtil.setStatUrl(configure.getStatUrl());
            UserStatUtil.setAgentId(configure.getAgentId());
            UserStatUtil.arthasStart();

            try {
                SpyAPI.init();
            } catch (Throwable e) {
                // ignore
            }

            logger().info("as-server started in {} ms", System.currentTimeMillis() - start);
        } catch (Throwable e) {
            logger().error("Error during start as-server", e);
            destroy();
            throw e;
        }
    }

参考：

https://blog.csdn.net/tianjindong0804/article/details/128423819

夜里慢慢行456
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Arthas源码分析（一）——Arthas启动
st940962913的博客
08-23 803
1. arthas-boot 不管是命令行还是as.sh，都是从这个jar包开始启动。这个jar算是启动arthas的门面，会检查本地是否存在最新版arthas相关的jar，如果没有就从网上下载，完成的主要功能是新开进程以命令行启动arthas-core.jar，同时以参数形式附带attach-pid、arthas-core.jar路径和arthas-agent.jar路径等重要信息。如下图所示。 等到加载完成之后，对其out和err重定向，再加载arthas-...
阿里arthas-tunnel-server-3.7.1-fatjar包
11-13
阿里arthas-tunnel-server-3.7.1-fatjar包
arthas源码刨析：启动 (1)
最新发布
u013257767的博客
08-21 217
arthas 在一些命令的执行需要有 JDK 命令的支持，以 ProcessUtils.select 为例，该方法实际上是要调用JAVA_HOME 下的 jps。启动类 Bootstrap ，开头的注解就是 alibaba 的 cli 中间件，和 picocli 蛮像。这就理解了 arthas 提升要用 stop 命令来推出，而不是关闭当前命名窗口，它是个多进程应用。后面就是启动关键模块 arthas-core。
arthas 源码构建
过了这个村没这个老王的博客
11-21 593
arthas 源码构建，记录了遇到的两个问题
Arthas源码解析
dw147258dw的专栏
06-25 331
代码 arthas-boot:arthas启动主程序，arthas推荐的启动方式 arthas-client:telnet连接工程 arthas-client:arthas核心包，里面也有主方法可以启动arthas arthas-spy:间谍程序，该包由启动类加载器加载，其他工程包由arthas自定义类加载器加载 一、从arthas-core中的Arthas看起： 1.Arthas.java中的主方法是启动方法，会执行到attachAgent()，我们从这个方法看起，这里的configure中有
淘宝放单源码Java-arthas-all-2021-04-25:arthas-all-2021-04-25
06-07
淘宝放单源码Java 阿尔萨斯 Arthas是阿里巴巴开源的 Java 诊断工具。 Arthas 允许开发人员在不修改代码或重新启动服务器的情况下解决 Java 应用程序的生产问题。 背景 很多时候，生产系统网络无法从本地开发环境访问...
Arthas（arthas-3.7.1.zip）
09-07
Arthas 是一款线上监控诊断产品，通过全局视角实时查看应用 load、内存、gc、线程的状态信息，并能在不修改应用代码的情况下，对业务问题进行诊断，包括查看方法调用的出入参、异常，监测方法执行耗时，类加载信息等...
arthas的源码，如果在github上无法下载的同学可通过我这里下载
06-08
1. **命令行工具**：Arthas提供了一个交互式的命令行界面，用户可以通过输入各种命令来查看和操作应用程序。 2. **类热更新**：在不重启服务的情况下，允许开发者更新类文件，这在开发和调试过程中非常有用。 3. *...
arthas最新版本arthas-packaging-3.7.0-bin
08-16
2. **AOP（面向切面编程）支持**：Arthas能够在线添加AOP切面，对运行中的代码进行拦截，这对于调试和优化非常有用。 3. **Classloader Debug**：由于Java的类加载机制可能导致一些问题，Arthas提供了强大的类加载...
接口测试的几种方法
2301_78843735的博客
08-14 1668
其实无论用那种测试方法，接口测试的原理是通过测试程序模拟客户端向服务器发送请求报文，服务器接收请求报文后对相应的报文做出处理然后再把应答报文发送给客户端，客户端接收应答报文这一个过程。大家都知道LoadRunner是一种性能测试工具，但它也可以用在我们做接口测试的时候。
第2章 C语言基础知识
m0_70617423的博客
08-14 2075
C语言
学习C语言第十五天
zh060515的博客
08-13 2214
结构体定义由关键字struct和结构体名组成，结构体名可以根据需要自行定义。struct 语句定义了一个包含多个成员的新数据类型...tag是结构体标签。是标准的变量定义，比如 int i;或者 float f;，或者其他有效的变量定义。结构变量，定义在结构的末尾，最后一个分号之前，可以指定一个或多个结构变量。
c语言编程有什么难点
2302_76972946的博客
08-14 1468
总结来说，C语言编程的难点涵盖了理论和实践的多个方面，从指针的使用、内存管理，到复杂数据结构的实现，再到并发编程和跨平台的适应，每一步都需要精确而深入的理解和实践。C语言编程面临的难点主要有1、指针的理解和使用、2、内存管理、3、复杂的数据结构实现、4、并发和多线程编程以及5、跨平台编程。理解指针的地址和指针变量之间的关系，如何通过指针读写数据，指针与数组、结构体等复杂数据类型的结合使用，都是学习过程中的难点。构建高效的数据结构不仅需要深厚的算法知识，也测试开发者对C语言细节的精细掌握。
python爬虫爬取某图书网页实例
2301_77698138的博客
08-14 3195
下面是通过requests库来对ajax页面进行爬取的案例，与正常页面不同，这里我们获取url的方式也会不同，这里我们通过爬取一个简单的ajax小说页面来为大家讲解。循环遍历URL（这里为大家提供具体url的获取方法，并循环了1至9页的数据为大家做案例），并发送了带有随机User-Agent的GET请求。设置代码来保存图片到以文章名命名的文件中，并将作者、文章名和简介信息写入到"./biquge.txt"文件中。首先进入网页，点击F12打开自定义与控制工具，点击fecth/XHR，此时显示部分为空白。
【链表在Java中DeBug】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 321
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
【Spring框架】
m0_71941456的博客
08-18 1033
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 552
【代码】springboot网上商品订单转手系统bootpf
指针详解（四）
Limerence_Aries的博客
08-18 1025
目录1. 字符指针变量2. 数组指针变量3. 数组指针变初始化4. 二维数组传参的本质5. 函数指针变量1）函数指针变量的创建2）函数指针变量的使用3）代码解析6. typedef关键字7. 函数指针数组8. 转移表 代码const char* pstr = "hello bit."; 不是把字符串 hello bit 放到字符指针 pstr 里，而是把字符串hello bit.的首字符的地址放到了pstr中我们通过一道例题加深理解 所以数组指针变量：存放的应该是数组的地址，能够指向数组的指针变
Arthas诊断工具指南：快速解决问题
"Arthas教程详解，一个由淘宝开源的Java诊断工具，适用于解决类加载、代码修改未生效、线上调试等问题。提供命令行交互和丰富的Tab自动补全功能，支持JDK 6及以上版本。包括快速入门、进阶使用、WebConsole等多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值