arthas簡介

arthas 是Alibaba開源的Java診斷工具，基於jvm Agent方式，使用Instrumentation方式修改字節碼方式以及使用java.lang.management包提供的管理接口的方式進行java應用診斷。詳細的介紹可以參考官方文檔。
官方文檔地址：https://alibaba.github.io/arthas/
GitHub地址：https://github.com/alibaba/arthas/
本文主要分析arthas源碼，主要分成下面幾個部分：

arthas組成模塊
arthas服務端代碼分析
arthas客戶端代碼分析

arthas組成模塊

arthas有多個模塊組成，如下圖所示：

arthas模塊圖.png

arthas-boot.jar和as.sh模塊功能類似，分別使用java和shell腳本，下載對應的jar包，並生成服務端和客戶端的啓動命令，然後啓動客戶端和服務端。服務端最終生成的啓動命令如下：

${JAVA_HOME}"/bin/java \
     ${opts}  \
     -jar "${arthas_lib_dir}/arthas-core.jar" \
         -pid ${TARGET_PID} \             要注入的進程id
         -target-ip ${TARGET_IP} \       服務器ip地址
         -telnet-port ${TELNET_PORT} \  服務器telnet服務端口號
         -http-port ${HTTP_PORT} \      websocket服務端口號
         -core "${arthas_lib_dir}/arthas-core.jar" \      arthas-core目錄
         -agent "${arthas_lib_dir}/arthas-agent.jar"    arthas-agent目錄

arthas-core.jar是服務端程序的啓動入口類，會調用virtualMachine#attach到目標進程，並加載arthas-agent.jar作爲agent jar包。
arthas-agent.jar既可以使用premain方式（在目標進程啓動之前，通過-agent參數靜態指定），也可以通過agentmain方式（在進程啓動之後attach上去）。arthas-agent會使用自定義的classloader(ArthasClassLoader)加載arthas-core.jar裏面的com.taobao.arthas.core.config.Configure類以及com.taobao.arthas.core.server.ArthasBootstrap。同時程序運行的時候會使用arthas-spy.jar。
arthas-spy.jar裏面只包含Spy類，目的是爲了將Spy類使用BootstrapClassLoader來加載，從而使目標進程的java應用可以訪問Spy類。通過ASM修改字節碼，可以將Spy類的方法ON_BEFORE_METHOD， ON_RETURN_METHOD等編織到目標類裏面。Spy類你可以簡單理解爲類似spring aop的Advice，有前置方法，後置方法等。
arthas-client.jar是客戶端程序，用來連接arthas-core.jar啓動的服務端代碼，使用telnet方式。一般由arthas-boot.jar和as.sh來負責啓動。

arthas服務端代碼分析

前置準備

看服務端啓動命令可以知道從 arthas-core.jar開始啓動，arthas-core的pom.xml文件裏面指定了mainClass爲com.taobao.arthas.core.Arthas，使得程序啓動的時候從該類的main方法開始運行。Arthas源碼如下：

public class Arthas {

    private Arthas(String[] args) throws Exception {
        attachAgent(parse(args));
    }

    private Configure parse(String[] args) {
        // 省略非關鍵代碼，解析啓動參數作爲配置，並填充到configure對象裏面
        return configure;
    }

    private void attachAgent(Configure configure) throws Exception {
           // 省略非關鍵代碼，attach到目標進程
          virtualMachine = VirtualMachine.attach("" + configure.getJavaPid());
          virtualMachine.loadAgent(configure.getArthasAgent(),
                            configure.getArthasCore() + ";" + configure.toString());
    }


    public static void main(String[] args) {
            new Arthas(args);
    }
}

Arthas首先解析入參，生成com.taobao.arthas.core.config.Configure類，包含了相關配置信息
使用jdk-tools裏面的VirtualMachine.loadAgent，其中第一個參數爲agent路徑，第二個參數向jar包中的agentmain()方法傳遞參數（此處爲agent-core.jar包路徑和config序列化之後的字符串），加載arthas-agent.jar包，並運行
arthas-agent.jar包，指定了Agent-Class爲com.taobao.arthas.agent.AgentBootstrap，同時可以使用Premain的方式和目標進程同時啓動

<manifestEntries>
    <Premain-Class>com.taobao.arthas.agent.AgentBootstrap</Premain-Class>
    <Agent-Class>com.taobao.arthas.agent.AgentBootstrap</Agent-Class>
</manifestEntries>

其中Premain-Class的premain和Agent-Class的agentmain都調用main方法。
main方法主要做4件事情：

找到arthas-spy.jar路徑，並調用Instrumentation#appendToBootstrapClassLoaderSearch方法，使用bootstrapClassLoader來加載arthas-spy.jar裏的Spy類。
arthas-agent路徑傳遞給自定義的classloader(ArthasClassloader)，用來隔離arthas本身的類和目標進程的類。
使用 ArthasClassloader#loadClass方法，加載com.taobao.arthas.core.advisor.AdviceWeaver類，並將裏面的methodOnBegin、methodOnReturnEnd、methodOnThrowingEnd等方法取出賦值給Spy類對應的方法。同時Spy類裏面的方法又會通過ASM字節碼增強的方式，編織到目標代碼的方法裏面。使得Spy 間諜類可以關聯由AppClassLoader加載的目標進程的業務類和ArthasClassloader加載的arthas類，因此Spy類可以看做兩者之間的橋樑。根據classloader雙親委派特性，子classloader可以訪問父classloader加載的類。源碼如下：

    private static ClassLoader getClassLoader(Instrumentation inst, File spyJarFile, File agentJarFile) throws Throwable {
        // 將Spy添加到BootstrapClassLoader
        inst.appendToBootstrapClassLoaderSearch(new JarFile(spyJarFile));

        // 構造自定義的類加載器ArthasClassloader，儘量減少Arthas對現有工程的侵蝕
        return loadOrDefineClassLoader(agentJarFile);
    }

    private static void initSpy(ClassLoader classLoader) throws ClassNotFoundException, NoSuchMethodException {
        // 該classLoader爲ArthasClassloader
        Class<?> adviceWeaverClass = classLoader.loadClass(ADVICEWEAVER);
        Method onBefore = adviceWeaverClass.getMethod(ON_BEFORE, int.class, ClassLoader.class, String.class,
                String.class, String.class, Object.class, Object[].class);
        Method onReturn = adviceWeaverClass.getMethod(ON_RETURN, Object.class);
        Method onThrows = adviceWeaverClass.getMethod(ON_THROWS, Throwable.class);
        Method beforeInvoke = adviceWeaverClass.getMethod(BEFORE_INVOKE, int.class, String.class, String.class, String.class);
        Method afterInvoke = adviceWeaverClass.getMethod(AFTER_INVOKE, int.class, String.class, String.class, String.class);
        Method throwInvoke = adviceWeaverClass.getMethod(THROW_INVOKE, int.class, String.class, String.class, String.class);
        Method reset = AgentBootstrap.class.getMethod(RESET);
        Spy.initForAgentLauncher(classLoader, onBefore, onReturn, onThrows, beforeInvoke, afterInvoke, throwInvoke, reset);
    }

classloader關係如下：

+-BootstrapClassLoader                                                                                                                                                                               
+-sun.misc.Launcher$ExtClassLoader@7bf2dede                                                                                                                                                          
  +-com.taobao.arthas.agent.ArthasClassloader@51a10fc8                                                                                                                                               
  +-sun.misc.Launcher$AppClassLoader@18b4aac2

異步調用bind方法，該方法最終啓動server監聽線程，監聽客戶端的連接，包括telnet和websocket兩種通信方式。源碼如下：

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

    private static void bind(Instrumentation inst, ClassLoader agentLoader, String args) throws Throwable {
            /**
            * <pre>
            * Configure configure = Configure.toConfigure(args);
            * int javaPid = configure.getJavaPid();
            * ArthasBootstrap bootstrap = ArthasBootstrap.getInstance(javaPid, inst);
            * </pre>
            */
            Class<?> classOfConfigure = agentLoader.loadClass(ARTHAS_CONFIGURE);
            Object configure = classOfConfigure.getMethod(TO_CONFIGURE, String.class).invoke(null, args);
            int javaPid = (Integer) classOfConfigure.getMethod(GET_JAVA_PID).invoke(configure);
            Class<?> bootstrapClass = agentLoader.loadClass(ARTHAS_BOOTSTRAP);
            Object bootstrap = bootstrapClass.getMethod(GET_INSTANCE, int.class, Instrumentation.class).invoke(null, javaPid, inst);
            boolean isBind = (Boolean) bootstrapClass.getMethod(IS_BIND).invoke(bootstrap);
            if (!isBind) {
                try {
                    ps.println("Arthas start to bind...");
                    bootstrapClass.getMethod(BIND, classOfConfigure).invoke(bootstrap, configure);
                    ps.println("Arthas server bind success.");
                    return;
                } catch (Exception e) {
                    ps.println("Arthas server port binding failed! Please check $HOME/logs/arthas/arthas.log for more details.");
                    throw e;
                }
            }
            ps.println("Arthas server already bind.");
        }

主要做兩件事情：

使用ArthasClassloader加載com.taobao.arthas.core.config.Configure類(位於arthas-core.jar)，並將傳遞過來的序列化之後的config，反序列化成對應的Configure對象。
使用ArthasClassloader加載com.taobao.arthas.core.server.ArthasBootstrap類（位於arthas-core.jar），並調用bind方法。

啓動服務器，並監聽客戶端請求

下面重點看下com.taobao.arthas.core.server.ArthasBootstrap#bind方法

    /**
     * Bootstrap arthas server
     *
     * @param configure 配置信息
     * @throws IOException 服務器啓動失敗
     */
    public void bind(Configure configure) throws Throwable {

        long start = System.currentTimeMillis();

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

        try {
            ShellServerOptions options = new ShellServerOptions()
                            .setInstrumentation(instrumentation)
                            .setPid(pid)
                            .setSessionTimeout(configure.getSessionTimeout() * 1000);
            shellServer = new ShellServerImpl(options, this);
            BuiltinCommandPack builtinCommands = new BuiltinCommandPack();
            List<CommandResolver> resolvers = new ArrayList<CommandResolver>();
            resolvers.add(builtinCommands);
            // TODO: discover user provided command resolver
            if (configure.getTelnetPort() > 0) {
                // telnet方式的server
                shellServer.registerTermServer(new TelnetTermServer(configure.getIp(), configure.getTelnetPort(),
                                options.getConnectionTimeout()));
            } else {
                logger.info("telnet port is {}, skip bind telnet server.", configure.getTelnetPort());
            }
            if (configure.getHttpPort() > 0) {
                // websocket方式的server
                shellServer.registerTermServer(new HttpTermServer(configure.getIp(), configure.getHttpPort(),
                                options.getConnectionTimeout()));
            } else {
                logger.info("http port is {}, skip bind http server.", configure.getHttpPort());
            }

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

            shellServer.listen(new BindHandler(isBindRef));

            logger.info("as-server listening on network={};telnet={};http={};timeout={};", configure.getIp(),
                    configure.getTelnetPort(), configure.getHttpPort(), options.getConnectionTimeout());
            // 異步回報啓動次數
            UserStatUtil.arthasStart();

            logger.info("as-server started in {} ms", System.currentTimeMillis() - start );
        } catch (Throwable e) {
            logger.error(null, "Error during bind to port " + configure.getTelnetPort(), e);
            if (shellServer != null) {
                shellServer.close();
            }
            throw e;
        }
    }

可以看到有兩種類型的server，TelnetTermServer和HttpTermServer。同時會在BuiltinCommandPack裏添加所有的命令Command，添加命令的源碼如下：

public class BuiltinCommandPack implements CommandResolver {

    private static List<Command> commands = new ArrayList<Command>();

    static {
        initCommands();
    }

    @Override
    public List<Command> commands() {
        return commands;
    }

    private static void initCommands() {
        commands.add(Command.create(HelpCommand.class));
        commands.add(Command.create(KeymapCommand.class));
        commands.add(Command.create(SearchClassCommand.class));
        commands.add(Command.create(SearchMethodCommand.class));
        commands.add(Command.create(ClassLoaderCommand.class));
        commands.add(Command.create(JadCommand.class));
        commands.add(Command.create(GetStaticCommand.class));
        commands.add(Command.create(MonitorCommand.class));
        commands.add(Command.create(StackCommand.class));
        commands.add(Command.create(ThreadCommand.class));
        commands.add(Command.create(TraceCommand.class));
        commands.add(Command.create(WatchCommand.class));
        commands.add(Command.create(TimeTunnelCommand.class));
        commands.add(Command.create(JvmCommand.class));
        // commands.add(Command.create(GroovyScriptCommand.class));
        commands.add(Command.create(OgnlCommand.class));
        commands.add(Command.create(DashboardCommand.class));
        commands.add(Command.create(DumpClassCommand.class));
        commands.add(Command.create(JulyCommand.class));
        commands.add(Command.create(ThanksCommand.class));
        commands.add(Command.create(OptionsCommand.class));
        commands.add(Command.create(ClsCommand.class));
        commands.add(Command.create(ResetCommand.class));
        commands.add(Command.create(VersionCommand.class));
        commands.add(Command.create(ShutdownCommand.class));
        commands.add(Command.create(SessionCommand.class));
        commands.add(Command.create(SystemPropertyCommand.class));
        commands.add(Command.create(SystemEnvCommand.class));
        commands.add(Command.create(RedefineCommand.class));
        commands.add(Command.create(HistoryCommand.class));
    }
}

調用shellServer.registerTermServer，shellServer.registerTermServer，shellServer.registerCommandResolve 註冊到ShellServer裏，ShellServer是整個服務端的門面類，調用listen方法啓動ShellServer。
ShellServer會使用一系列的類，細節比較複雜，可以見下面的類圖。

Arthas-服務端類圖.png

ShellServer#listen會調用所有註冊的TermServer的listen方法，比如TelnetTermServer。然後TelnetTermServer的listen方法會註冊一個回調類，該回調類在有新的客戶端連接時會調用TermServerTermHandler的handle方法處理。

        bootstrap = new NettyTelnetTtyBootstrap().setHost(hostIp).setPort(port);
        try {
            bootstrap.start(new Consumer<TtyConnection>() {
                @Override
                public void accept(final TtyConnection conn) {
                    termHandler.handle(new TermImpl(Helper.loadKeymap(), conn));
                }
            }).get(connectionTimeout, TimeUnit.MILLISECONDS);
            listenHandler.handle(Future.<TermServer>succeededFuture());

該方法會接着調用ShellServerImpl的handleTerm方法進行處理，ShellServerImpl的handleTerm方法會調用ShellImpl的readline方法。該方法會註冊ShellLineHandler作爲回調類，服務端接收到客戶端發送的請求行之後，會回調ShellLineHandler的handle方法處理請求。readline方法源碼如下：

    public void readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler) {
        if (conn.getStdinHandler() != echoHandler) {
            throw new IllegalStateException();
        }
        if (inReadline) {
            throw new IllegalStateException();
        }
        inReadline = true;
        // 註冊回調類RequestHandler，該類包裝了ShellLineHandler，處理邏輯還是在ShellLineHandler類裏面
        readline.readline(conn, prompt, new RequestHandler(this, lineHandler), new CompletionHandler(completionHandler, session));
    }

處理客戶端請求

ShellLineHandler的handle方法會根據不同的請求命令執行不同的邏輯：

如果是exit,logout,quit, jobs,fg,bg,kill等直接執行。
如果是其他的命令，則創建Job，並運行。創建Job的類圖如下：

服務端-創建job類圖.png

步驟比較多，就不一一細講，總之：
創建Job時，會根據具體客戶端傳遞的命令，找到對應的Command，幷包裝成Process, Process再被包裝成Job。
運行Job時，反向先調用Process，再找到對應的Command，最終調用Command的process處理請求。

Command處理流程

Command主要分爲兩類：

不需要使用字節碼增強的命令
其中JVM相關的使用 java.lang.management 提供的管理接口，來查看具體的運行時數據。比較簡單，就不介紹了。
需要使用字節碼增強的命令
字節碼增強的命令，可以參考下圖：

arthas-command相關類圖.png

字節碼增加的命令統一繼承EnhancerCommand類，process方法裏面調用enhance方法進行增強。調用Enhancer類enhance方法，該方法內部調用inst.addTransformer方法添加自定義的ClassFileTransformer，這邊是Enhancer類。

Enhancer類使用AdviceWeaver(繼承ClassVisitor)，用來修改類的字節碼。重寫了visitMethod方法，在該方法裏面修改類指定的方法。visitMethod方法裏面使用了AdviceAdapter（繼承了MethodVisitor類），在onMethodEnter方法, onMethodExit方法中，把Spy類對應的方法（ON_BEFORE_METHOD， ON_RETURN_METHOD， ON_THROWS_METHOD等）編織到目標類的方法對應的位置。

在前面Spy初始化的時候可以看到，這幾個方法其實指向的是AdviceWeaver類的methodOnBegin， methodOnReturnEnd等。在這些方法裏面都會根據adviceId查找對應的AdviceListener，並調用AdviceListener的對應的方法，比如before,afterReturning, afterThrowing。

通過這種方式，可以實現不同的Command使用不同的AdviceListener，從而實現不同的處理邏輯。下面找幾個常用的AdviceListener介紹下:

StackAdviceListener
在方法執行前，記錄堆棧和方法的耗時。
WatchAdviceListener
滿足條件時打印打印參數或者結果，條件表達式使用Ognl語法。
TraceAdviceListener
在每個方法前後都記錄，並維護一個調用樹結構。

arthas客戶端代碼分析

客戶端代碼在arthas-client模塊裏面，入口類是com.taobao.arthas.client.TelnetConsole。主要使用apache commons-net jar進行telnet連接，關鍵的代碼有下面幾步：

構造TelnetClient對象，並初始化
構造ConsoleReader對象，並初始化
調用IOUtil.readWrite(telnet.getInputStream(), telnet.getOutputStream(), System.in, consoleReader.getOutput())處理各個流，一共有四個流：

telnet.getInputStream()
telnet.getOutputStream()
System.in
consoleReader.getOutput()

請求時：從本地System.in讀取，發送到 telnet.getOutputStream()，即發送給遠程服務端。
響應時：從telnet.getInputStream()讀取遠程服務端發送過來的響應，並傳遞給 consoleReader.getOutput()，即在本地控制檯輸出。

arthas源碼分析

arthas簡介

arthas組成模塊

arthas服務端代碼分析

前置準備

啓動服務器，並監聽客戶端請求

處理客戶端請求

Command處理流程

arthas客戶端代碼分析

win11關閉自動檢測病毒刪文件

JAVA中不要用e.printStackTrace()

MySQL索引優化——索引優化

Git 簡要使用

五分鐘瞭解Mysql的行級鎖

虛擬機使用NAT模式連接網絡設置

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結