---------------------------------------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

在排查Java的CPU性能问题时，找出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环境配置：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 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.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();
    }

}