java 收集linux信息

public class MachineCollector
  implements Runnable
{
  private static int DEFAULT_INTERVAL = 30;
  private boolean isStopped = false;
  private RandomAccessFile procNetDevReader;
  private RandomAccessFile procMemInfoReader;
  private RandomAccessFile procLoadAvgReader;
  private RandomAccessFile procStatReader;
  private RandomAccessFile procCpuInfoReader;
  private static final Map<String, String> memInterestKey = new HashMap();
  private static final String[] cpuIndexName = { "cpu-place-holder", "cpu_user", "cpu_nice", "cpu_system", "cpu_idle", "cpu_iowait", "cpu_irq", "cpu_softirq", "cpu_steal", "cpu_guest", "cpu_guest_nice" };
  private static final Map<String, Long> cpuPreInfo = new HashMap();
  private static boolean cpuPreInfoEmpty = true;
  private static final Logger logger = Logger.getLogger(MachineCollector.class);
  private static MachineCollector instance = new MachineCollector();
 
  static
  {
    memInterestKey.put("MemTotal", "mem_total");
    memInterestKey.put("MemFree", "mem_free");
    memInterestKey.put("Buffers", "mem_buffer");
    memInterestKey.put("Cached", "mem_cached");
    memInterestKey.put("SwapCached", "swap_cached");
    memInterestKey.put("SwapTotal", "swap_total");
    memInterestKey.put("SwapFree", "swap_free");
  }
 
  public static MachineCollector getInstance()
  {
    return instance;
  }
 
  private MachineCollector()
  {
    try
    {
      this.procNetDevReader = new RandomAccessFile("/proc/net/dev", "r");
      this.procMemInfoReader = new RandomAccessFile("/proc/meminfo", "r");
      this.procLoadAvgReader = new RandomAccessFile("/proc/loadavg", "r");
      this.procStatReader = new RandomAccessFile("/proc/stat", "r");
      this.procCpuInfoReader = new RandomAccessFile("/proc/cpuinfo", "r");
    }
    catch (FileNotFoundException e)
    {
      logger.error("No such file, Is /proc mounted?", e);
    }
  }
 
  public void start()
  {
    if (this.isStopped) {
      return;
    }
    new Thread(this).start();
  }
 
  public void run()
  {
    this.isStopped = false;
    while (!this.isStopped)
    {
      Map<String, Object> info = getInfoFromProcFile();
      
      sendInfoByJson(info);
      try
      {
        Thread.sleep(DEFAULT_INTERVAL * 1000);
      }
      catch (InterruptedException e)
      {
        e.printStackTrace();
      }
    }
  }
 
  public void stop()
  {
    this.isStopped = true;
  }
 
  private Map<String, Object> getInfoFromProcFile()
  {
    Map<String, Object> info = new HashMap();
    
    readMemUsage(info);
    readSysOverload(info);
    readCpuUsage(info);
    readDiskUsage(info);
    
    readCpuInfo(info);

readNetTraffic(info);
    
    return info;
  }
 
  private void readMemUsage(Map<String, Object> info)
  {
    String line = null;
    try
    {
      int keysNotRead = memInterestKey.size();
      this.procMemInfoReader.seek(0L);
      while (((line = this.procMemInfoReader.readLine()) != null) && (keysNotRead != 0))
      {
        int sepIndex = line.indexOf(":");
        
        String key = line.substring(0, sepIndex);
        if (memInterestKey.containsKey(key))
        {
          info.put(memInterestKey.get(key), line.substring(sepIndex + 1, line.length() - 2).trim());
          keysNotRead--;
        }
      }
    }
    catch (Exception e)
    {
      logger.error("read /proc/meminfo error", e);
    }
  }
 
  private void readSysOverload(Map<String, Object> info)
  {
    String line = null;
    String[] terms = null;
    try
    {
      this.procLoadAvgReader.seek(0L);
      line = this.procLoadAvgReader.readLine();
      
      terms = line.trim().split("\\s+");
      
      info.put("load_avg1", terms[0]);
      info.put("load_avg5", terms[1]);
      info.put("load_avg15", terms[2]);
    }
    catch (Exception e)
    {
      logger.error("read /proc/loadavg error", e);
    }
  }
 
  private void readCpuUsage(Map<String, Object> info)
  {
    String line = null;
    String[] terms = null;
    try
    {
      this.procStatReader.seek(0L);
      line = this.procStatReader.readLine();
      if (!line.startsWith("cpu")) {
        return;
      }
      Long total_p = Long.valueOf(0L);
      Long total_n = Long.valueOf(0L);
      if (!cpuPreInfoEmpty) {
        for (Map.Entry<String, Long> et : cpuPreInfo.entrySet()) {
          total_p = Long.valueOf(total_p.longValue() + ((Long)et.getValue()).longValue());
        }
      }
      Map<String, Long> cpuNowInfo = new HashMap();
      
      terms = line.split("\\s+");
      for (int i = 1; i < terms.length; i++)
      {
        long ticks = Long.parseLong(terms[i]);
        total_n = Long.valueOf(total_n.longValue() + ticks);
        
        cpuNowInfo.put(cpuIndexName[i], Long.valueOf(ticks));
      }
      Long total_dif;
      if (cpuPreInfoEmpty)
      {
        cpuPreInfoEmpty = false;
      }
      else
      {
        total_dif = Long.valueOf(total_n.longValue() - total_p.longValue());
        for (Map.Entry<String, Long> et : cpuNowInfo.entrySet())
        {
          Long cpu_p = (Long)cpuPreInfo.get(et.getKey());
          Long cpu_n = (Long)cpuNowInfo.get(et.getKey());

double cpu = (cpu_n.longValue() - cpu_p.longValue()) / total_dif.longValue() * 100.0D;
          
          info.put(et.getKey(), Double.valueOf(cpu));
        }
      }
      for (Map.Entry<String, Long> et : cpuNowInfo.entrySet()) {
        cpuPreInfo.put(et.getKey(), et.getValue());
      }
    }
    catch (Exception e)
    {
      logger.error("read /proc/stat error", e);
    }
  }
 
  private void readCpuInfo(Map<String, Object> info)
  {
    String line = null;
    try
    {
      this.procCpuInfoReader.seek(0L);
      
      int cpuCoreNum = 0;
      while ((line = this.procCpuInfoReader.readLine()) != null) {
        if (line.startsWith("processor")) {
          cpuCoreNum++;
        }
      }
      info.put("cpu_core", Integer.valueOf(cpuCoreNum));
    }
    catch (Exception e)
    {
      logger.error("read /proc/cpuinfo error", e);
    }
  }
 
  private void readDiskUsage(Map<String, Object> info)
  {
    File fsroot = new File("/");
    
    long disk_total = fsroot.getTotalSpace() >> 20;
    long disk_free = fsroot.getFreeSpace() >> 20;
    long disk_usable = fsroot.getUsableSpace() >> 20;
    
    info.put("disk_total", String.valueOf(disk_total));
    info.put("disk_free", String.valueOf(disk_free));
    info.put("disk_usable", String.valueOf(disk_usable));
  }
 
  private void readNetTraffic(Map<String, Object> info)
  {
    String line = null;
    try
    {
      this.procNetDevReader.seek(0L);

this.procNetDevReader.readLine();
      this.procNetDevReader.readLine();
      
      List<Map<String, String>> netinfos = new ArrayList();
      while ((line = this.procNetDevReader.readLine()) != null)
      {
        line = line.trim();
        int sep = line.indexOf(':');
        
        String dev = line.substring(0, sep);
        String rline = line.substring(sep + 1);
        if ((!dev.equals("lo")) && (!dev.startsWith("sit")))
        {
          Map<String, String> netinfo = new HashMap();
          
          String[] terms = rline.trim().split("\\s+");
          
          netinfo.put("dev_name", dev);
          netinfo.put("rx_bytes", terms[0]);
          netinfo.put("rx_packets", terms[1]);
          netinfo.put("tx_bytes", terms[8]);
          netinfo.put("tx_packets", terms[9]);
          
          netinfos.add(netinfo);
        }
      }
      info.put("net_devs", netinfos);
    }
    catch (Exception e)
    {
      logger.error("read /proc/net/dev error", e);
    }
  }
 
  private void sendInfoByJson(Map<String, Object> info)
  {
    if (info.containsKey("cpu_user"))
    {
      String json = JSON.toJSONString(info);
      try
      {
        Message message = new Message();
        message.setBody(json.getBytes(Charset.forName("UTF-8")));
        
        message.setCollectcode(Message.COLLECT_CODE.COLLECT_MACHINE);
        message.setBusinesscode(Message.SUB_COLLECT_CODE.SC_MAC_DEF);
        message.setIp(MonitorModule.ipn);
        
        message.setTimestamp(new Date().getTime());
        message.setBiz_name("".getBytes(Charset.forName("UTF-8")));
        message.setBiz_name_s(0);
        
        message.setTotalLen(message.getBody().length + 24);
        
        Sender.send(message);
      }
      catch (Exception e)
      {
        logger.error("get local ip as int", e);
      }
    }
  }
 
  @Deprecated
  public static Map<String, Number> getInfobyExec()
  {
    result = new HashMap();
    InputStream is = null;
    InputStreamReader isr = null;
    BufferedReader brStat = null;
    Process process = null;
    try
    {
      process = Runtime.getRuntime().exec("top -b -n 1");
      is = process.getInputStream();
      isr = new InputStreamReader(is, Charset.forName("UTF-8"));
      brStat = new BufferedReader(isr);
      
      String tem = brStat.readLine();
      String[] terms = tem.trim().split("[,:]{1}");
      String loadaverage1 = terms[(terms.length - 3)];
      String loadaverage5 = terms[(terms.length - 2)];
      String loadaverage15 = terms[(terms.length - 1)];
      
      result.put("load_avg1", new Double(loadaverage1));
      result.put("load_avg5", new Double(loadaverage5));
      result.put("load_avg15", new Double(loadaverage15));
      
      tem = brStat.readLine();
      terms = tem.trim().split("[,:]{1}");
      String total_task = terms[1].trim().split(" ")[0];
      String runnung_task = terms[2].trim().split(" ")[0];
      String sleeping_task = terms[3].trim().split(" ")[0];
      String stopped_task = terms[4].trim().split(" ")[0];
      String zombie_task = terms[5].trim().split(" ")[0];
      
      result.put("total_task", new Integer(total_task));
      result.put("runnung_task", new Integer(runnung_task));
      result.put("sleeping_task", new Integer(sleeping_task));
      result.put("stopped_task", new Integer(stopped_task));
      result.put("zombie_task", new Integer(zombie_task));
      
      tem = brStat.readLine();
      terms = tem.trim().split("[,:]{1}");
      String cpu_us = terms[1].split("%")[0];
      String cpu_id = terms[4].split("%")[0];
      
      result.put("cpu_us", new Double(cpu_us));
      result.put("cpu_idle", new Double(cpu_id));
      
      tem = brStat.readLine();
      terms = tem.trim().split("[,:]{1}");
      String mem_total = terms[1].trim().split(" ")[0].replace("k", "");
      String mem_used = terms[2].trim().split(" ")[0].replace("k", "");
      String mem_free = terms[3].trim().split(" ")[0].replace("k", "");
      
      result.put("mem_total", new Long(mem_total));
      result.put("mem_used", new Long(mem_used));
      result.put("mem_free", new Long(mem_free));
      
      tem = brStat.readLine();
      terms = tem.trim().split("[,:]{1}");
      String swap_total = terms[1].trim().split(" ")[0].replace("k", "");
      String swap_used = terms[2].trim().split(" ")[0].replace("k", "");
      String swap_free = terms[3].trim().split(" ")[0].replace("k", "");
      
      result.put("swap_total", new Long(swap_total));
      result.put("swap_used", new Long(swap_used));
      result.put("swap_free", new Long(swap_free));

return result;
    }
    catch (Exception ex)
    {
      logger.error(ex.getMessage(), ex);
    }
    finally
    {
      try
      {
        if (is != null) {
          is.close();
        }
        if (isr != null) {
          isr.close();
        }
        if (brStat != null) {
          brStat.close();
        }
        if (process != null)
        {
          try
          {
            process.waitFor();
          }
          catch (InterruptedException e)
          {
            e.printStackTrace();
          }
          process.destroy();
        }
      }
      catch (IOException ex)
      {
        logger.error(ex.getMessage(), ex);
      }
    }
  }
 
  public static void setInterval(Integer interval)
  {
    DEFAULT_INTERVAL = interval.intValue();
  }
}