精华内容
下载资源
问答
  • java应用cpu使用率过高问题排查

    万次阅读 热门讨论 2018-07-18 23:59:59
    1、先通过top命令找到消耗cpu很高的进程id假设是123 2、执行top -p 123单独监控该进程 3、在第2步的监控界面输入H,获取当前进程下的所有线程信息 4、找到消耗cpu特别高的线程编号,假设是123 5、...

    ---------------------------------------linux下如何定位代码问题-------------------------------

    1、先通过top命令找到消耗cpu很高的进程id假设是123

    2、执行top -p 123单独监控该进程

    3、在第2步的监控界面输入H,获取当前进程下的所有线程信息

    4、找到消耗cpu特别高的线程编号,假设是123

    5、执行jstack 123456对当前的进程做dump,输出所有的线程信息

    6 将第4步得到的线程编号11354转成16进制是0x7b

    7 根据第6步得到的0x7b在第5步的线程信息里面去找对应线程内容

    8 解读线程信息,定位具体代码位置

    -----------------------------分割线----------------------------------------------

     

    最近在压力测试工作中碰到java应用某台机器cpu比较高的情况,特地下笔记以后总结:

    一个简单的淘宝认证接口 需要插入读写数据库2次。每次爬取数据,入库。完成。

    正常情况下:

    应用使用cpu在 :50%--80%

    压力高--异常情况下:

    cpu利用率在:90%---90%

    在网上查了下,一般java应用cpu过高基本上是因为

    1.程序计算比较密集

    2.程序死循环

    3.程序逻请求堵塞
    4.IO读写太高 

    方法一:

    分析步骤:

    1.登陆应用机器,top -d 1命令查看 当前占用cpu资源最多的,一般排名第一位肯定是java进程

    一般也可能存在多个java进程 

     

    观察 top 消耗第一的资源是PID=1679的线程

    2.查看进程的哪个线程占用cpu比较高,取线上另外一台正常情况下利用cpu比较高的应用:通过

    ps -mp pid -o THREAD,tid,time命令查看该进程的线程情况

    通过以上线程CPU切片 耗时在pid=1679 Tid =1896 耗时 1分59秒,4%CPU占用最大。时间最长。

    TID为1679的线程利用cpu资源比较多,怎么能看到这个线程在干什么呢?

    需要将1896 转换为16进制,便于在jvm堆栈中查找。

    printf "%x\n" 1896   ----768

    通过jstack命令来查看下当前内存状态:

     定位到cpu过高是IO读写太高 ,接下来就是找开发人员确认这段代码是否可以优化。

     

    方法二:

    在做压测的时候,开发给了一个工具  show-busy-java-threads.sh

    在排查JavaCPU性能问题时,找出Java进程中消耗cpu多(top us值过高)的线程,查看它的线程栈,从而找出有性能问题的方法调用。

    ####截取一段

    #!/bin/bash
    # @Function
    # Find out the highest cpu consumed threads of java, and print the stack of these threads.
    #
    # @Usage
    #   $ ./show-busy-java-threads.sh
    #
    # @author Jerry Lee
     
    readonly PROG=`basename $0`
    readonly -a COMMAND_LINE=("$0" "$@")
     
    usage() {
        cat <<EOF
    Usage: ${PROG} [OPTION]...
    Find out the highest cpu consumed threads of java, and print the stack of these threads.
    Example: ${PROG} -c 10
    
    ...................后面略

    其实就是个shell文件,把这个文件上传到目标服务器(linux),记得更改文件的读写权限: chmod -R 777  show-busy-java-threads.sh

    附:脚本链接https://download.csdn.net/download/qq_34944965/13780146

    接方法一  top之后,只需要下命令 :./show-busy-java-threads.sh -p pid  后面CPU占用高的定位就分析出来了,具体如图

     

     

    展开全文
  • java 通过服务器ip以及snmp协议读取cpu使用率,和内存使用率 **github地址:**https://github.com/Plumblumpb/snmp-demo.git 环境配置 window环境配置:...

    java 通过服务器ip以及snmp协议读取cpu使用率,和内存使用率

    github地址 https://github.com/Plumblumpb/snmp-demo.git

    环境配置

    window环境配置:https://jingyan.baidu.com/article/7f766dafe17d394101e1d0f9.html
    linux环境配置:https://blog.csdn.net/c_royi/article/details/86640800

    代码及运行流程

      pom.xml文件

     <dependency>
         <groupId>org.snmp4j</groupId>
         <artifactId>snmp4j</artifactId>
         <version>2.5.11</version>
     </dependency>
    
    

      实体类(存储ip,port,version,等信息)
    没有展示getter,setter方法

    **
     * @Auther: cpb
     * @Date: 2019/1/24 10:41
     * @Description:
     */
    public class SnmpModel {
        private String communityName;
        private String hostIp;
        private Integer port;
        private int version;
        private int async;//是否同步查询
    
        private String serverId; // 受监控服务器标识
        private String code; // 受监控服务器编码
        private String name; // 受监控服务器名称
        private String type; // 服务器的应用类型(如应用服务,数据库服务,前置机服务器),在维护时输入,在界面中相应字段呈现
        private String systemName; // 受监控服务器操作系统
        private String ip; // 受监控服务器IP地址
        private String address; // 受监控服务的存放地址
        private String statusid; // 状态(1为可用,0为不可用,默认为1),用于是否对这个服务器进行监控
        private String remark; // 备注
        private String cpu;
        private String memory;
        private String time;
        private boolean ethernetConnection;
    
        // 服务service字段
        private String serviceId; // 受监控服务标识
        private String serviceName; // 受监控服务名称
        private String serverName; // 受监控服务所在服务器名称
        private String serverIp; // 受监控服务所在服务器IP
        private String processeName; // 受监控服务进行名称
        private String serviceStatus; // 状态(1为可用,0为禁用,默认值为1),用于是否对这个服务进程进行监控
        private String serviceRemark; // 备注
    }
    

      snmp服务类

    import org.apache.log4j.Logger;
    import java.io.IOException;
    import java.net.InetAddress;
    import java.util.List;
    
    /**
     * @Auther: cpb
     * @Date: 2019/1/24 10:42
     * @Description:
     */
    public class SnmpService {
        private static final Logger logger = Logger.getLogger(SnmpService.class);
        SnmpDao snmpDao = new SnmpDao();
    
        public SnmpDao getInstanceSnmpDao() {
            return snmpDao;
        }
        /**
         * 获取CPU使用率
         *
         * @param snmpModel
         * @return 正常返回CPU当前使用率,否则返回-1
         */
        public Integer getCpuUtilization(SnmpModel snmpModel) {
            List<String> result = getInstanceSnmpDao().walkByTable(
                    ".1.3.6.1.2.1.25.3.3.1.2", snmpModel);
            if (result == null || result.size() == 0) {
                return -1;
            }
            double sum = 0;
            for (String s : result) {
                sum += Double.parseDouble(s);
            }
            return (int) (sum / result.size());
        }
    
        /**
         * 获取Memory占用率
         *
         * @param snmpModel
         * @return 正常返回当前内存使用率,否则返回-1
         * @throws IOException
         */
        public Integer getMemoryUtilization(SnmpModel snmpModel){
    
            // 使用
            try{
                List<String> usedresultList = getInstanceSnmpDao().walkByTable(".1.3.6.1.2.1.25.2.3.1.6", snmpModel);
                // 总
                List<String> allresultList = getInstanceSnmpDao().walkByTable(".1.3.6.1.2.1.25.2.3.1.5", snmpModel);
    
                if (usedresultList != null && usedresultList.size() > 0 && allresultList !=null && allresultList.size() >0) {
    
                    double used = 0;
                    // 最后一个才是使用的内存(单位是数目 ) 因系统而不同 本机有5项
                    // System.out.println(usedresultList.size());
                    // for(String s:usedresultList){
                    // System.out.println(s);
                    // }
                    String usedStr = usedresultList.get(usedresultList.size() - 1);
                    used = Double.parseDouble(usedStr);
                    double all = 0;
                    String allStr = allresultList.get(allresultList.size() - 1);
                    all = Double.parseDouble(allStr);
                    return (int) ((used / all) * 100);
                }
            }catch (Exception e) {
                logger.error("获取Memory占用率:"+e.getMessage());
            }
            return -1;
        }
    
        /**
         * 测网络通不通 类似 ping ip
         *
         * @param snmpModel
         * @return
         * @throws IOException
         */
        public boolean isEthernetConnection(SnmpModel snmpModel) throws IOException {
    
            InetAddress ad = InetAddress.getByName(snmpModel.getHostIp());
            boolean state = ad.isReachable(2000);// 测试是否可以达到该地址 2秒超时
            return state;
        }
    
    
    
    }
    
    

      snmp实现类

    
    import org.apache.log4j.Logger;
    import org.snmp4j.CommunityTarget;
    import org.snmp4j.PDU;
    import org.snmp4j.Snmp;
    import org.snmp4j.smi.OID;
    import org.snmp4j.smi.OctetString;
    import org.snmp4j.smi.UdpAddress;
    import org.snmp4j.smi.VariableBinding;
    import org.snmp4j.transport.DefaultUdpTransportMapping;
    import org.snmp4j.util.DefaultPDUFactory;
    import org.snmp4j.util.TableEvent;
    import org.snmp4j.util.TableUtils;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @Auther: cpb
     * @Date: 2019/1/24 10:43
     * @Description:
     */
    public class SnmpDao {
        private String communityName;
        private String hostIp;
        private Integer port;
        private int version;
        private static final Logger logger = Logger.getLogger(SnmpDao.class);
    
        /**
         * 获取指定OID对应的table值
         * @param oid
         * @param snmpModel
         * @return
         */
        public List<String> walkByTable(String oid, SnmpModel snmpModel){
            //initSnmp(snmpModel);
    
            Snmp snmp = null;
            PDU pdu;
            CommunityTarget target;
            List<String> result = new ArrayList<String>();
    
            communityName = snmpModel.getCommunityName();
            hostIp = snmpModel.getHostIp();
            port = snmpModel.getPort();
            version = snmpModel.getVersion();
            try {
                DefaultUdpTransportMapping dm = new DefaultUdpTransportMapping();
    //			dm.setSocketTimeout(5000);
                snmp = new Snmp(dm);
                snmp.listen();
                target = new CommunityTarget();
                target.setCommunity(new OctetString(communityName));
                target.setVersion(version);
                target.setAddress(new UdpAddress(hostIp+"/"+port));
                target.setTimeout(1000);
                target.setRetries(1);
    
                TableUtils tutils = new TableUtils(snmp, new DefaultPDUFactory(PDU.GETBULK));
                OID[] columns = new OID[1];
                columns[0] = new VariableBinding(new OID(oid)).getOid();
                List<TableEvent> list = (List<TableEvent>) tutils.getTable(target, columns, null, null);
                for(TableEvent e : list){
                    VariableBinding[] vb = e.getColumns();
                    if(null == vb)continue;
                    result.add(vb[0].getVariable().toString());
    //				 System.out.println(vb[0].getVariable().toString());
                }
                snmp.close();
            } catch (IOException e) {
                //e.printStackTrace();
                logger.error(e.getMessage());
            }finally{
                try {
                    if(snmp != null)
                    {
                        snmp.close();
                    }
                } catch (IOException e) {
                    logger.error(e.getMessage());
                }
            }
            return result;
    
        }
    }
    
    

      方法测试

    import java.io.IOException;
    
    /**
     * @Auther: cpb
     * @Date: 2019/1/24 10:45
     * @Description:
     */
    public class Demo {
        public static void main(String[] args) {
            SnmpService snmpService = new SnmpService();
            SnmpModel snmpModel = new SnmpModel();
            snmpModel.setIp("127.0.0.1");
            snmpModel.setCommunityName("public");
            snmpModel.setHostIp("127.0.0.1");
            snmpModel.setPort(161);
            snmpModel.setVersion(1);
            try {
                //是否连接
                System.out.println("是否连接:"+snmpService.isEthernetConnection(snmpModel));
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("cpu利用率:"+ snmpService.getCpuUtilization(snmpModel));
            System.out.println("内存使用率:"+ snmpService.getMemoryUtilization(snmpModel));
    
        }
    }
    
    

    测试结果

    在这里插入图片描述

    展开全文
  • import java.io.File; import java.io.InputStreamReader; import java.io.LineNumberReader; import java.lang.management.ManagementFactory; import java.util.ArrayList; import java.util.List; import

    import java.io.File;
    import java.io.InputStreamReader;
    import java.io.LineNumberReader;
    import java.lang.management.ManagementFactory;
    import java.util.ArrayList;
    import java.util.List;

    import com.sun.management.OperatingSystemMXBean;

    /**
     * 获取windows系统信息(CPU,内存,文件系统)
     * 
     * @author libing
     * 
     */

    public class WindowsInfoUtil {
     private static final int CPUTIME = 500;
     private static final int PERCENT = 100;
     private static final int FAULTLENGTH = 10;

     public static void main(String[] args) {
      System.out.println(getCpuRatioForWindows());
      System.out.println(getMemery());
      System.out.println(getDisk());
     }

     // 获取内存使用率
     public static String getMemery() {
      OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory
        .getOperatingSystemMXBean();
      // 总的物理内存+虚拟内存
      long totalvirtualMemory = osmxb.getTotalSwapSpaceSize();
      // 剩余的物理内存
      long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize();
      Double compare = (Double) (1 - freePhysicalMemorySize * 1.0
        / totalvirtualMemory) * 100;
      String str = "内存已使用:" + compare.intValue() + "%";
      return str;
     }

     // 获取文件系统使用率
     public static List<String> getDisk() {
      // 操作系统
      List<String> list = new ArrayList<String>();
      for (char c = 'A'; c <= 'Z'; c++) {
       String dirName = c + ":/";
       File win = new File(dirName);
       if (win.exists()) {
        long total = (long) win.getTotalSpace();
        long free = (long) win.getFreeSpace();
        Double compare = (Double) (1 - free * 1.0 / total) * 100;
        String str = c + ":盘  已使用 " + compare.intValue() + "%";
        list.add(str);
       }
      }
      return list;
     }

     // 获得cpu使用率
     public static String getCpuRatioForWindows() {
      try {
       String procCmd = System.getenv("windir")
         + "//system32//wbem//wmic.exe process get Caption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";
       // 取进程信息
       long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));
       Thread.sleep(CPUTIME);
       long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));
       if (c0 != null && c1 != null) {
        long idletime = c1[0] - c0[0];
        long busytime = c1[1] - c0[1];
        return "CPU使用率:"
          + Double.valueOf(
            PERCENT * (busytime) * 1.0
              / (busytime + idletime)).intValue()
          + "%";
       } else {
        return "CPU使用率:" + 0 + "%";
       }
      } catch (Exception ex) {
       ex.printStackTrace();
       return "CPU使用率:" + 0 + "%";
      }
     }

     // 读取cpu相关信息
     private static long[] readCpu(final Process proc) {
      long[] retn = new long[2];
      try {
       proc.getOutputStream().close();
       InputStreamReader ir = new InputStreamReader(proc.getInputStream());
       LineNumberReader input = new LineNumberReader(ir);
       String line = input.readLine();
       if (line == null || line.length() < FAULTLENGTH) {
        return null;
       }
       int capidx = line.indexOf("Caption");
       int cmdidx = line.indexOf("CommandLine");
       int rocidx = line.indexOf("ReadOperationCount");
       int umtidx = line.indexOf("UserModeTime");
       int kmtidx = line.indexOf("KernelModeTime");
       int wocidx = line.indexOf("WriteOperationCount");
       long idletime = 0;
       long kneltime = 0;
       long usertime = 0;
       while ((line = input.readLine()) != null) {
        if (line.length() < wocidx) {
         continue;
        }
        // 字段出现顺序:Caption,CommandLine,KernelModeTime,ReadOperationCount,
        // ThreadCount,UserModeTime,WriteOperation
        String caption = substring(line, capidx, cmdidx - 1).trim();
        String cmd = substring(line, cmdidx, kmtidx - 1).trim();
        if (cmd.indexOf("wmic.exe") >= 0) {
         continue;
        }
        String s1 = substring(line, kmtidx, rocidx - 1).trim();
        String s2 = substring(line, umtidx, wocidx - 1).trim();
        if (caption.equals("System Idle Process")
          || caption.equals("System")) {
         if (s1.length() > 0)
          idletime += Long.valueOf(s1).longValue();
         if (s2.length() > 0)
          idletime += Long.valueOf(s2).longValue();
         continue;
        }
        if (s1.length() > 0)
         kneltime += Long.valueOf(s1).longValue();
        if (s2.length() > 0)
         usertime += Long.valueOf(s2).longValue();
       }
       retn[0] = idletime;
       retn[1] = kneltime + usertime;
       return retn;
      } catch (Exception ex) {
       ex.printStackTrace();
      } finally {
       try {
        proc.getInputStream().close();
       } catch (Exception e) {
        e.printStackTrace();
       }
      }
      return null;
     }

     /**
      * 由于String.subString对汉字处理存在问题(把一个汉字视为一个字节),因此在 包含汉字的字符串时存在隐患,现调整如下:
      * 
      * @param src
      *            要截取的字符串
      * @param start_idx
      *            开始坐标(包括该坐标)
      * @param end_idx
      *            截止坐标(包括该坐标)
      * @return
      */
     private static String substring(String src, int start_idx, int end_idx) {
      byte[] b = src.getBytes();
      String tgt = "";
      for (int i = start_idx; i <= end_idx; i++) {
       tgt += (char) b[i];
      }
      return tgt;
     }
    }

    展开全文
  • Java获取cpu数量,cpu使用率 如下是spring-boot监控服务spring-boot-starter-actuator源码中获取cpu个数,cpu使用率的方式. import com.sun.management.OperatingSystemMXBean; import java.lang.management....

    Java获取cpu数量,cpu使用率


    如下是spring-boot监控服务spring-boot-starter-actuator源码中获取cpu个数,cpu使用率的方式.
    import com.sun.management.OperatingSystemMXBean;
    
    import java.lang.management.ManagementFactory;
    
    /**
     * @author luckhwb
     */
    public class SystemUtil {
        
        private static OperatingSystemMXBean operatingSystemMXBean;
    
        static {
            operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
        }
    
        /**
         * 获取cpu使用率
         * @return
         */
        public static double getSystemCpuLoad() {
            return operatingSystemMXBean.getSystemCpuLoad();
        }
    
        /**
         * 获取cpu数量
         * @return
         */
        public static int getSystemCpuCount() {
            return Runtime.getRuntime().availableProcessors();
        }
    
    }
    
    
    展开全文
  • 按《Java进程CPU使用率高排查》方法查看堆栈信息,发现有个方法很可疑,发给开发人员查看,觉得表数据量太大,查询没有走索引,新建索引后,感觉情况有好转。 排查步骤如下: 1.使用top 定位到占用CPU高的进程...
  • java查看CPU使用率

    2013-01-07 15:44:18
    Bytes.java class Bytes { public static String substring(String src, int start_idx, int end_idx){ byte[] b = src.getBytes(); String tgt = ""; for(int i=start_idx; i...
  • /**  *  ...package com.test.cpumem; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.logging.Logger; /**  * Linux下,ja
  • 以下是网上某博客代码,特点是通过window和linux命令获得CPU使用率。  public class MonitorInfoBean { /** 可使用内存. */ private long totalMemory; /** 剩余内存. */ private lon
  • 2.查看进程中线程使用cpu情况 通过ps -mp pid -o THREAD,tid,time命令查看该进程的线程情况 3.将线程ID转换16进制 printf "%x\n" 4139 102b 4.根据线程id使用jstack观察线程信息 jstack 4130 |grep 102b 5....
  • Java中,可以获得总的物理内存、剩余的物理内存、已使用的物理内存等信息,下面例子可以取得这些信息,并且获得在Windows下的内存使用率。 首先编写一个MonitorInfoBean类,用来装载监控的一些信息,包
  • 花式读取Android CPU使用率

    万次阅读 2017-09-11 01:22:59
    1.介绍常见的获取android cpu使用率的方法 2.介绍这些常见方法背后的原理 3.介绍我自己写的一个脚本,这个脚本可以获取各个线程在cpu各个核上的占用率一、常见的获取Android CPU使用率方法及其原理首先说一下如何...
  • cpu使用率如何计算 计算使用率在上学那会就经常算,不过往往计算的是整个程序执行的时间段,现在突然要实时计算还真有点无奈,时间段如何选择是个问题。最后根据现有的程序做参考,那就是Linux的top...
  • 说明:cpu使用率,可以采用jdk8原生的方法,但是有博客说不太准确,这里不做说明。 import cn.hzp.util.linuxinfo.bean.CpuInfoBean; import com.sun.management.OperatingSystemMXBean; import l
  • 一般情况: 1.程序计算比较密集 2.程序死循环 3.程序逻请求堵塞 4.IO读写太高    参考:https://blog.csdn.net/qq_34944965/article/details/81107419
  • 内容来源于本人博客园博客在发布新版的MYPM时,加密要用到相关硬件信息,于是写了下面的测试类 读取(MAC地址,CPU号,硬盘卷标,CPU型号及CPU使用率等信息)
  • Java获取CPU占用

    千次阅读 2019-09-25 05:45:34
    原文链接:... 最近做一个Java性能统计的问题,需要统计当前进程占用CPU的情况,最开始使用Java MxBean来获取 OperatingSystemMXBean osMxBean = ManagementFactory.getOperatingSystemMXBean(); ...
  • Linux下使用java获取cpu、内存使用率

    千次阅读 2019-09-25 05:45:14
    思路如下:Linux系统中可以用top命令查看进程使用CPU和内存情况,通过Runtime类的exec()方法执行命令"top”,获取"top"的输出,从而得到CPU和内存的使用情况。 使用top命令获取系统信息: top -b -n -1...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,559
精华内容 25,823
关键字:

java读取cpu使用率

java 订阅