精华内容
下载资源
问答
  • java 监控linux服务器cpu使用率、内存使用率、磁盘使用率、java进程是否存活等服务.pdf
  • java监控linux cpu使用率

    2010-07-15 10:29:17
    java实现linux下的cpu资源使用率监控
  • Linux进程查看命令 PS命令 1.不带参数的ps使用 2.显示所有的当前进程 ps –ax -a 代表 all。同时加上x参数会显示没有控制终端的进程。 ps -ax | less 可以结合less命令和管道来使用以方便查看。 3.通过cpu和...

    Linux进程查看命令

    PS命令

    • 1.不带参数的ps使用
      这里写图片描述

    • 2.显示所有的当前进程

      ps –ax  -a 代表 all。同时加上x参数会显示没有控制终端的进程。
      ps -ax | less 可以结合less命令和管道来使用以方便查看。
      
    • 3.通过cpu和内存使用来过滤进程

      ps -aux | less
      默认的结果集是未排好序的。可以通过 –sort命令来排序。
      

    根据 CPU 使用来升序排序
    ps -aux --sort -pcpu | less
    根据 内存使用 来升序排序
    ps -aux --sort -pmem | less
    我们也可以将它们合并到一个命令,并通过管道显示前10个结果:
    ps -aux --sort -pcpu,+pmem | head -n 10

    ```
    
    • 4.通过进程名和PID过滤

      ps -f -C [进程名]
      ps -f -C mysqld
      

    这里写图片描述

    • 5.树形显示进程
      这里写图片描述

    • 6.查看所有关于java的进程

      ps -ef | grep java
      

    top命令

    • 1.top命令经常用来监控Linux的系统状况,比如cpu、内存的使用。
      这里写图片描述

    • 2.第一行:

      第一块:当前系统时间
      第二块:系统已经运行了3天23小时26分
      第三块:当前有1个用户登录系统
      第四块:load average后面的三个数分别是1分钟、5分钟、15分钟的负载情况。load average数据是每隔5秒钟检查一次活跃的进程数,然后按特定算法计算出的数值。如果这个数除以逻辑CPU的数量,结果高于5的时候就表明系统在超负荷运转了。
      
    • 3.第二行:

      第一块:系统现在有431个进程
      第二块:有一个进程处于运行状态
      第三块:428个进程处于休眠状态
      第四块:0个进程处于stopped状态
      第五块:2个进程处于zombie状态
      
    • 4.第三行:cpu状态

      0.4 us — 用户空间占用CPU的百分比。
      0.5 sy — 内核空间占用CPU的百分比。
      0.0 ni — 改变过优先级的进程占用CPU的百分比
      99.0 id — 空闲CPU百分比
      0.0 wa — IO等待占用CPU的百分比
      0.0 hi — 硬中断(Hardware IRQ)占用CPU的百分比
      0.0 si — 软中断(Software Interrupts)占用CPU的百分比
      

    用户空间就是用户进程所在的内存区域,相对的,系统空间就是操作系统占据的内存区域。用户进程和系统进程的所有数据都在内存中。
    ```

    • 5.第四行:内存状态(单位k)

      16237008 total — 物理内存总量(16.2GB)
      10904524 used — 使用中的内存总量(10.9GB)
      1984320  free — 空闲内存总量(2.0G)
      3348164  buffers — 缓存的内存量 (3.3G)
      
    • 6.第五行:swap交换分区

      5119996 total — 交换区总量(5GB)
      0       used — 使用的交换区总量(0)
      5119996 free — 空闲交换区总量(5GB)
      4800960 cached — 缓冲的交换区总量(4.8GB)
      

      可用内存数的近似的计算公式:第四行的free + 第四行的buffers + 第五行的cached。
      我们最关心的内存监控是第五行swap(类似于虚拟内存)交换分区的used,如果这个数值在不断的变化,说明内核在不断进行内存和swap的数据交换,这是可以判定服务器的内存不够用了。

    • 7.第六行:各进程(任务)的状态监控

      PID — 进程id
      USER — 进程所有者
      PR — 进程优先级
      NI — nice值。负值表示高优先级,正值表示低优先级
      VIRT — 进程使用的虚拟内存总量,单位kb。VIRT=SWAP+RES
      RES — 进程使用的、未被换出的物理内存大小,单位kb。RES=CODE+DATA
      SHR — 共享内存大小,单位kb
      S — 进程状态。D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程
      %CPU — 上次更新到现在的CPU时间占用百分比
      %MEM — 进程使用的物理内存百分比
      TIME+ — 进程使用的CPU时间总计,单位1/100秒
      COMMAND — 进程名称(命令名/命令行)
      

    线程查看命令

    top –H(列出所有的线程)

    这里写图片描述

    让top输出某个特定进程[pid]并检查该进程内运行的线程状况

    ```
    让top输出某个特定进程[pid]并检查该进程内运行的线程状况:
    top -H -p [pid]
    
    ```
    

    这里写图片描述

    查看由进程号为[pid]的进程创建的所有线程

    ```
    ps -T -p [pid]
    ```
    

    这里写图片描述

    Java线程监控分析(一般流程)

    1.先用top命令找出占用资源比较多的java进程id

    这里写图片描述
    我们以第一个进程为例,对该进程的所有线程进行监控

    2.查看相关进程的所有线程

    这里写图片描述
    接下来我们以第一个线程为例,对其进行监控分析

    3.然后借助JVM的 jconsole.exe 工具对相应线程进行具体分析

    这里写图片描述
    jconsole具体使用细节可以参考 https://blog.csdn.net/ithomer/article/details/9923311 ,这里就不做过多的介绍了。

    扫码关注公众号

    • 后台回复“Linux及Docker学习资料”免费获取更多Linux及Docker学习教材及实战资料
      在这里插入图片描述
    展开全文
  • yarn任务邮件监控linux进程邮件监控,定时检查 ,本人在生产环境使用的,可以监控yarn任务,各种进程 如namenode ,java jar进程,如果不明白可以留言或者联系我(文档里面有联系方式)
  • Linux平台 下 进程监控自动 重启 恢复脚本, 测试 centos平台下 java, springboot 通过
  • Java监控Linux服务器 Top 状态

    千次阅读 2021-06-04 17:09:39
    <dependency> <groupId>com.jcraft</groupId> <artifactId>jsch</artifactId> <version>0.1.55<...import java.io.BufferedReader; import java.io.IOException;

    <dependency>
      <groupId>com.jcraft</groupId>
      <artifactId>jsch</artifactId>
      <version>0.1.55</version>
    </dependency>
    
    import com.jcraft.jsch.*;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
     
    /**
     * 远程调用Linux shell 命令
     *
     * @author wei.Li by 14-9-2.
     */
    class LinuxStateForShell {
     
     
        public static final String CPU_MEM_SHELL = "top -b -n 1";
        public static final String FILES_SHELL = "df -hl";
        public static final String[] COMMANDS = {CPU_MEM_SHELL, FILES_SHELL};
        public static final String LINE_SEPARATOR = System.getProperty("line.separator");
        private static Session session;
     
        /**
         * 连接到指定的HOST
         *
         * @return isConnect
         * @throws JSchException JSchException
         */
        private static boolean connect(String user, String passwd, String host) {
            JSch jsch = new JSch();
            try {
                session = jsch.getSession(user, host, 22);
                session.setPassword(passwd);
     
                java.util.Properties config = new java.util.Properties();
                config.put("StrictHostKeyChecking", "no");
                session.setConfig(config);
     
                session.connect();
            } catch (JSchException e) {
                e.printStackTrace();
                System.out.println("connect error !");
                return false;
            }
            return true;
        }
     
        /**
         * 远程连接Linux 服务器 执行相关的命令
         *
         * @param commands 执行的脚本
         * @param user     远程连接的用户名
         * @param passwd   远程连接的密码
         * @param host     远程连接的主机IP
         * @return 最终命令返回信息
         */
        public static Map<String, String> runDistanceShell(String[] commands, String user, String passwd, String host) {
            if (!connect(user, passwd, host)) {
                return null;
            }
            Map<String, String> map = new HashMap<>();
            StringBuilder stringBuffer;
     
            BufferedReader reader = null;
            Channel channel = null;
            try {
                for (String command : commands) {
                    stringBuffer = new StringBuilder();
                    channel = session.openChannel("exec");
                    ((ChannelExec) channel).setCommand(command);
     
                    channel.setInputStream(null);
                    ((ChannelExec) channel).setErrStream(System.err);
     
                    channel.connect();
                    InputStream in = channel.getInputStream();
                    reader = new BufferedReader(new InputStreamReader(in));
                    String buf;
                    while ((buf = reader.readLine()) != null) {
     
                        //舍弃PID 进程信息
                        if (buf.contains("PID")) {
                            break;
                        }
                        stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                    }
                    //每个命令存储自己返回数据-用于后续对返回数据进行处理
                    map.put(command, stringBuffer.toString());
                }
            } catch (IOException | JSchException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (reader != null) {
                        reader.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (channel != null) {
                    channel.disconnect();
                }
                session.disconnect();
            }
            return map;
        }
     
     
        /**
         * 直接在本地执行 shell
         *
         * @param commands 执行的脚本
         * @return 执行结果信息
         */
        public static Map<String, String> runLocalShell(String[] commands) {
            Runtime runtime = Runtime.getRuntime();
     
            Map<String, String> map = new HashMap<>();
            StringBuilder stringBuffer;
     
            BufferedReader reader;
            Process process;
            for (String command : commands) {
                stringBuffer = new StringBuilder();
                try {
                    process = runtime.exec(command);
                    InputStream inputStream = process.getInputStream();
                    reader = new BufferedReader(new InputStreamReader(inputStream));
                    String buf;
                    while ((buf = reader.readLine()) != null) {
                        //舍弃PID 进程信息
                        if (buf.contains("PID")) {
                            break;
                        }
                        stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                    }
     
                } catch (IOException e) {
                    e.printStackTrace();
                    return null;
                }
                //每个命令存储自己返回数据-用于后续对返回数据进行处理
                map.put(command, stringBuffer.toString());
            }
            return map;
        }
     
     
        /**
         * 处理 shell 返回的信息
         * <p>
         * 具体处理过程以服务器返回数据格式为准
         * 不同的Linux 版本返回信息格式不同
         *
         * @param result shell 返回的信息
         * @return 最终处理后的信息
         */
        private static String disposeResultMessage(Map<String, String> result) {
     
            StringBuilder buffer = new StringBuilder();
     
            for (String command : COMMANDS) {
                String commandResult = result.get(command);
                if (null == commandResult) continue;
     
                if (command.equals(CPU_MEM_SHELL)) {
                    String[] strings = commandResult.split(LINE_SEPARATOR);
                    //将返回结果按换行符分割
                    for (String line : strings) {
                        line = line.toUpperCase();//转大写处理
     
                        //处理CPU Cpu(s): 10.8%us,  0.9%sy,  0.0%ni, 87.6%id,  0.7%wa,  0.0%hi,  0.0%si,  0.0%st
                        if (line.startsWith("CPU(S):")) {
                            String cpuStr = "CPU 用户使用占有率:";
                            try {
                                cpuStr += line.split(":")[1].split(",")[0].replace("US", "");
                            } catch (Exception e) {
                                e.printStackTrace();
                                cpuStr += "计算过程出错";
                            }
                            buffer.append(cpuStr).append(LINE_SEPARATOR);
     
                            //处理内存 Mem:  66100704k total, 65323404k used,   777300k free,    89940k buffers
                        } else if (line.startsWith("MEM")) {
                            String memStr = "内存使用情况:";
                            try {
                                memStr += line.split(":")[1]
                                        .replace("TOTAL", "总计")
                                        .replace("USED", "已使用")
                                        .replace("FREE", "空闲")
                                        .replace("BUFFERS", "缓存");
     
                            } catch (Exception e) {
                                e.printStackTrace();
                                memStr += "计算过程出错";
                                buffer.append(memStr).append(LINE_SEPARATOR);
                                continue;
                            }
                            buffer.append(memStr).append(LINE_SEPARATOR);
     
                        }
                    }
                } else if (command.equals(FILES_SHELL)) {
                    //处理系统磁盘状态
                    buffer.append("系统磁盘状态:");
                    try {
                        buffer.append(disposeFilesSystem(commandResult)).append(LINE_SEPARATOR);
                    } catch (Exception e) {
                        e.printStackTrace();
                        buffer.append("计算过程出错").append(LINE_SEPARATOR);
                    }
                }
            }
     
            return buffer.toString();
        }
     
        //处理系统磁盘状态
     
        /**
         * Filesystem            Size  Used Avail Use% Mounted on
         * /dev/sda3             442G  327G   93G  78% /
         * tmpfs                  32G     0   32G   0% /dev/shm
         * /dev/sda1             788M   60M  689M   8% /boot
         * /dev/md0              1.9T  483G  1.4T  26% /ezsonar
         *
         * @param commandResult 处理系统磁盘状态shell执行结果
         * @return 处理后的结果
         */
        private static String disposeFilesSystem(String commandResult) {
            String[] strings = commandResult.split(LINE_SEPARATOR);
     
            // final String PATTERN_TEMPLATE = "([a-zA-Z0-9%_/]*)\\s";
            int size = 0;
            int used = 0;
            for (int i = 0; i < strings.length - 1; i++) {
                if (i == 0) continue;
     
                int temp = 0;
                for (String s : strings[i].split("\\b")) {
                    if (temp == 0) {
                        temp++;
                        continue;
                    }
                    if (!s.trim().isEmpty()) {
                        if (temp == 1) {
                            size += disposeUnit(s);
                            temp++;
                        } else {
                            used += disposeUnit(s);
                            temp = 0;
                        }
                    }
                }
            }
            return new StringBuilder().append("大小 ").append(size).append("G , 已使用").append(used).append("G ,空闲")
                    .append(size - used).append("G").toString();
        }
     
        /**
         * 处理单位转换
         * K/KB/M/T 最终转换为G 处理
         *
         * @param s 带单位的数据字符串
         * @return 以G 为单位处理后的数值
         */
        private static int disposeUnit(String s) {
     
            try {
                s = s.toUpperCase();
                String lastIndex = s.substring(s.length() - 1);
                String num = s.substring(0, s.length() - 1);
                int parseInt = Integer.parseInt(num);
                if (lastIndex.equals("G")) {
                    return parseInt;
                } else if (lastIndex.equals("T")) {
                    return parseInt * 1024;
                } else if (lastIndex.equals("M")) {
                    return parseInt / 1024;
                } else if (lastIndex.equals("K") || lastIndex.equals("KB")) {
                    return parseInt / (1024 * 1024);
                }
            } catch (NumberFormatException e) {
                e.printStackTrace();
                return 0;
            }
            return 0;
        }
     
        public static void main(String[] args) {
    //        Map<String, String> result = runDistanceShell(COMMANDS, "root", "admin123", "192.168.1.1");
    
            System.out.println(disposeResultMessage(runLocalShell(COMMANDS)));
        }
     
    }
    
    展开全文
  • linux java 服务 添加监控 linuxjava服务,需要监控堆栈,内存,线程等信息,借助Windows 的jdk 监控工具监控。 1、在启脚本加上 (本机ip 和端口) -Djava.rmi.server.hostname=192.168.1.1 -Dcom.sun....

    linux  java  服务 添加监控

    linux的java服务,需要监控堆栈,内存,线程等信息,借助Windows 的jdk 监控工具监控。

    1、在启脚本加上 (本机ip 和端口)

    -Djava.rmi.server.hostname=192.168.1.1  -Dcom.sun.management.jmxremote.port=9880 -Dcom.sun.management.jmxremote.rmi.port=9880 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false

    2、打开 Windows jdk安装目录 bin底下 的  jvisualvm.exe

     然后填上上边的ip和端口即可

    展开全文
  • 很简单, 监控linux进程内存的脚本
  • linux安装Arthas监控java进程

    千次阅读 2019-02-27 10:15:14
    方法执行监控 watch 方法执行数据观测 trace 方法内部调用路径,并输出方法路径上的每个节点上耗时 stack 输出当前方法被调用的调用路径 tt 方法执行数据的时空隧道,记录下指定方法每次...

    1:查看本机是否安装telnet

    # rpm -qa | grep telnet

    2:安装telnet

    # yum install xinetd

    # yum install telnet

    # yum install telnet-server

    重启xinetd   service xinetd restart

    3:下载arthas安装包

    https://github.com/MartinDai/Arthas/raw/master/arthas.tar.gz

    • 安装: 执行 ./install.sh
    • 启动: 执行 ./as.sh pid

    4:arthas 常用指令

    dashboard

    当前系统的实时数据面板

    thread

    查看当前 JVM 的线程堆栈信息

    jvm

    查看当前 JVM 的信息

    sc

    查看JVM已加载的类信息

    sm

    查看已加载类的方法信息

    jad

    反编译指定已加载类的源码

    classloader

    查看classloader的继承树,urls,类加载信息,使用classloader去getResource

    monitor

    方法执行监控

    watch

    方法执行数据观测

    trace

    方法内部调用路径,并输出方法路径上的每个节点上耗时

    stack

    输出当前方法被调用的调用路径

    tt

    方法执行数据的时空隧道,记录下指定方法每次调用的入参和返回信息,并能对这些不同的时间下调用进行观测

    reset

    重置增强类,将被 Arthas 增强过的类全部还原,Arthas 服务端关闭时会重置所有增强过的类

    quit

    退出当前 Arthas 客户端,其他 Arthas 客户端不受影响

    shutdown

    关闭 Arthas 服务端,所有 Arthas 客户端全部退出

     

     

     

     

     

    展开全文
  • 主要为大家分享一个监控linux进程的shell脚本,当程序异常退出时可以自动重启,涉及到捕获进程信号与重启进程的命令与知识
  • jconsole远程监控Linux上运行的Java进程的方法: 1,在Java进程启动的时候讲监听命名放进启动命令行中 nohup java #后台启动 -Djava.rmi.server.hostname=192.168.202.27 #java进程所在的Linux ip,该行命名可以不...
  • zabbix自动发现JAVA进程,并进行自动添加监控JAVA 进程的JVM数据,统计分析告警监控。 支持多种中间件,tomcat、weblogic、微服务方式部署JAVA应用监控。 自带发现脚本和监控脚本,以及zabbix导入模板。
  • 通过Prometheus和Grafana监控Linux进程

    千次阅读 2019-08-05 07:45:00
    不论你是Linux系统管理员还是DevOps工程师,你都会花很多时间来追踪服务的性能指标。有时,你可能会遇到运行速度非常慢的实例,但你找不到任何引发问题的线索。有时,你可...
  • Linux - (tomcat) java进程监控及守护

    千次阅读 2017-11-15 13:08:40
    Linux服务器下需要监控某些进程的状态. 当进程不存在时, 自动启动, 当进程异常时, 自动重启. 以tomcat为例 1. 编写监控脚本(/data/bin/monitor.sh) #!/bin/sh #加载环境变量 #ALL source /etc/profile #MINE ...
  • 提供两个脚本,监控linux进程,如果进程挂了,自动重启。
  • shell监控Linux服务进程

    2012-12-17 15:53:34
    监控所需要的服务进程,如果不存在就记录日志或者报警。 #!/bin/sh IP=`ifconfig eth0 | grep "inet addr" | cut -f 2 -d ":" | cut -f 1 -d " "` JAVA_DIR=/usr/java/default/bin/java MYSQL_DIR=/service/...
  • 脚本内容:java_check.sh #! /bin/bash # if [ -z `pidof java` ]; then echo -e `date +%Y-%m-%d` `date +%R`. “33[31m33[1m(JAVA)Process does not exist! 33[0m” >> /data/logs/java_check.log /usr/local/...
  • Linux查看java进程

    2020-04-25 21:55:19
    linux下 1.查看"java" 相关的进程信息ps-ef|grepjava ps -ef|grep java 2. 停止特定java进程命令:kill-9java进程序号 kill-9java进程序号 ...
  • linux进程监控及管理

    千次阅读 2017-05-10 21:18:17
    Linux 系统状态的查看及管理工具 进程相关 pstree ps默认显示当前终端中的进程 字段含义 STAT 进程状态 常用组合 进程优先级调整 nice OPTION COMMAND ARG 执行时指定 renice -n priority pid top命令输入r然后根据...
  • 使用Arthas监控Java进程

    万次阅读 2018-10-13 13:50:42
    使用Arthas监控ElasticSearch5.安装过程可能遇到的问题 一、Arthas简介 Arthas 是Alibaba开源的Java诊断工具,深受开发者喜爱。 当你遇到以下类似问题而束手无策时,Arthas可以帮助你解决: 这个类从哪个 jar 包...
  • 本篇呢,注重说下visualVM怎么监控java进程 首先将你项目Jar包上传到linux上 参考博文:https://blog.csdn.net/xigua_0616/article/details/88911841 我发布的这篇文章中,有涉及相关mvn打包和本地ja...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,982
精华内容 24,392
关键字:

java监控linux进程

java 订阅
linux 订阅