linux各發行版本的系統資源獲取方式調研

一、各linux發行版本信息統計

linux發行版本中獲取系統資源的文件中字段對比如下圖所示：

發行版本	cpu	cpu load	net	disk	net_io	memery	內核版本
	/proc/stat	/proc/loadavg	/proc/net/dev	/etc/mtab	/proc/diskstats	/proc/meminfo
CentOS-6.4	10個字段 user sys nice …	取前3個字段   1分鐘負載     5分鐘負載    15分鐘負載	字段相同，取 Receive和 Transmit 中的bytes列	前三列: filesystem  mount on filesystem type	14個字段，取第6和第10個字段sector read sector write	MemTotal MemFree SwapFree	2.6.32-358.el6.x86_64
CentOS-6.5	10個字段	同上	同上	同上	同上	同上	2.6.32-431.el6.x86_64
CentOS-7.0	10個字段	同上	同上	同上	同上	同上	3.10.0-123.el7.x86_64
rhel-server-5.5	9個字段	同上	同上	同上	同上	同上	2.6.18-194.el5
rhel-server-6.3	10個字段	同上	同上	同上	同上	同上	2.6.32-279.el6.x86_64
rhel-server-6.4	10個字段	同上	同上	同上	同上	同上	2.6.32-358.el6.x86_64
Ubuntu-12.04.5-server	11個字段	同上	同上	同上	同上	同上	3.13.0-32-generic
Ubuntu-15.05.4-server	11個字段	同上	同上	同上	同上	同上	3.19.0-15-generic
Ubuntu-17.05.4-server	11個字段	同上	同上	同上	同上	同上	4.10.0-19-generic
SLES-11-SPA	11個字段	同上	同上	同上	同上	同上	linux-63h3 3.0.101-63-default

 

二、目前問題

1、獲取cpu數據

問題：/proc/stat文件字段個數不同，但是目前測試至少有9個字段。（現在程序中只讀了前7個字段。）

 

CentOS 6.5:

user (38082)      從系統啓動開始累計到當前時刻，處於用戶態的運行時間，不包含 nice值爲負的進程。

system (27594) 從系統啓動開始累計到當前時刻，處於核心態的運行時間。

nice (627)           從系統啓動開始累計到當前時刻，nice值爲負的進程所佔用的CPU時間。

idle (893908)     從系統啓動開始累計到當前時刻，除IO等待時間以外的其它等待時間。

iowait (12256)  從系統啓動開始累計到當前時刻，IO等待時間(since 2.5.41)。 內核版本

irq (581)             從系統啓動開始累計到當前時刻，硬中斷時間(since 2.6.0-test4)。

softirq (895)     從系統啓動開始累計到當前時刻，軟中斷時間(since2.6.0-test4)。

stealstolen(0)   which is the time spent in otheroperating systems when running in a virtualizedenvironment(since 2.6.11)。

guest(0)       whichis the time spent running a virtual CPU  for guest operating systems under the control ofthe Linux kernel(since 2.6.24)。

 

2、獲取磁盤容量：

通過讀取/etc/mtab文件，獲取所有掛載點，然後通過java File類中函數獲取掛載點的總空間和使用空間；

 

File file =new File(dir);

file.getTotalSpace()，file.getUsableSpace();

 

注：/etc/fstab   /etc/mtab  /proc/mounts 均可獲取磁盤掛載點信息；但每當 mount掛載分區、umount 卸載分區，都會動態更新 mtab，mtab  總是保持着當前系統中已掛載的分區信息，fdisk、df 這類程序，必須要讀取 mtab 文件，才能獲得當前系統中的分區掛載情況。

 http://www.metsky.com/archives/711.html

 

 

問題：在/etc/mtab文件中有很多虛擬文件的信息：是否需要過濾（現在將掛載點的總空間爲0的掛載點過濾掉，這樣獲取的數據和df –h 命令得到的數據一致）

ubuntu17.04

3、獲取磁盤IO

通過讀取 /proc/diskstats 文件，分別獲取每個磁盤一秒內的讀扇區數和寫扇區數（取2個時間點的數據[當前時刻和下一秒]，然後做差）；最後將所有的磁盤讀寫扇區數各自相加(一個扇區是512Byte，如果換算成KB，需要除以2，1KB=2*512Byte; 512Byte=1扇區數)

現在過濾了(loop 和ram  [loop:虛擬塊設備，影射正常文件,ram:將內存的一部分當做磁盤來用])

計算方法參照：

http://www.360doc.com/content/14/0603/14/14935022_383255906.shtml

 

問題： 現在的程序獲取到的磁盤1秒內的讀寫量（單位：KB）與IOstat 命令1秒內的數據統計(iostat -k 1)基本一致，但是與zabbix的統計是不同的。

 

目前，cpu使用率,網絡IO速率，磁盤IO速率都是通過sleep(1000) 獲取的，用採集器每隔20s獲取一次的方式會存在數據丟失。

三、java實現

package com.yoyosys.crawler.system_info;
import java.io.BufferedReader;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.log4j.Logger;  
import com.alibaba.fastjson.JSON;
import com.yoyosys.crawler.DataObject;
  
/** 
 * 取得linux系統下的cpu、內存信息 
 */
public final class LinuxSystemTool {
	
    private static Logger log = Logger.getLogger(LinuxSystemTool.class); 
   // private final static float TotalBandwidth = 1000;   //網口帶寬,Mbps
    
    private static LinuxSystemTool linuxSystemTool = new LinuxSystemTool();
    
    public  static LinuxSystemTool getInstance(){
    	return linuxSystemTool;
    	
    }
 
    /**
     * 單位是 Byte
     * @param list
     * @return
     * @throws IOException
     * @throws InterruptedException
     */
    public static long[] getMemInfo(List<DataObject> list) throws IOException, InterruptedException {  
    	
    	File file = new File("/proc/meminfo");
        BufferedReader br = new BufferedReader(new InputStreamReader(  
                new FileInputStream(file)));  
        long[] result = new long[4];  
        String str = null;  
        StringTokenizer token = null;
       
        while ((str = br.readLine()) != null) {  
            token = new StringTokenizer(str);  
            if (!token.hasMoreTokens())  
                continue;  
  
            str = token.nextToken();  
            if (!token.hasMoreTokens())
                continue;  
  
            if (str.equalsIgnoreCase("MemTotal:")){
            	String memtotal=token.nextToken();
                result[0] = Long.parseLong(memtotal);  
                DataObject memTotalData= new DataObject();
                memTotalData.setClock(System.currentTimeMillis());
                memTotalData.setKey("vm.memory.size[total]");
                memTotalData.setValue(result[0] * 1024 + "");
                list.add(memTotalData);
            } else if (str.equalsIgnoreCase("MemFree:"))  {
            	String memFree=token.nextToken();
                result[1] = Long.parseLong(memFree);  
                DataObject memFreeData= new DataObject();
                memFreeData.setClock(System.currentTimeMillis());
                memFreeData.setKey("vm.memory.size[free]");
                memFreeData.setValue(result[1] * 1024 + "");
                list.add(memFreeData);
            } else if (str.equalsIgnoreCase("SwapTotal:"))  {
            	String swapTotal=token.nextToken();
                result[2] = Long.parseLong(swapTotal);  
                DataObject swapTotalData= new DataObject();
                swapTotalData.setClock(System.currentTimeMillis());
                swapTotalData.setKey("system.swap.size[,total]");
                swapTotalData.setValue(result[2] * 1024 +"");
                list.add(swapTotalData);
            } else if (str.equalsIgnoreCase("SwapFree:"))  {
            	String swapFree=token.nextToken();
                result[3] = Long.parseLong(swapFree);  
                DataObject swapFreeData= new DataObject();
                swapFreeData.setClock(System.currentTimeMillis());
                swapFreeData.setKey("system.swap.size[,free]");
                swapFreeData.setValue(result[3]*1024 +"");
                list.add(swapFreeData);
            }
           
            
        }  
        // float  memUsage = 1- (float)freeMem/(float)totalMem; 
        float  mem_pused = 1- (float)result[1]/(float)result[0];
        DataObject memUsageData= new DataObject();
        memUsageData.setClock(System.currentTimeMillis());
        memUsageData.setKey("vm.memory.size[pused]");
        memUsageData.setValue(mem_pused+"" );
        list.add(memUsageData);
        
        float swap_pfree=(float)result[3]/(float)result[2];
        DataObject swapUsageData= new DataObject();
        swapUsageData.setClock(System.currentTimeMillis());
        swapUsageData.setKey("system.swap.size[,pfree]");
        swapUsageData.setValue(swap_pfree+"");
        list.add(swapUsageData);
        
        long swap_used=result[2]-result[3];
        DataObject swapUsedData= new DataObject();
        swapUsedData.setClock(System.currentTimeMillis());
        swapUsedData.setKey("system.swap.size[,used]");
        swapUsedData.setValue(swap_used*1024 +"");
        list.add(swapUsedData);
           
        long mem_used=result[0]-result[1];
        DataObject memUsedData= new DataObject();
        memUsedData.setClock(System.currentTimeMillis());
        memUsedData.setKey("vm.memory.size[used]");
        memUsedData.setValue(mem_used*1024 +"");
        list.add(memUsedData);
        
        return result;  
        
    }  
    
    /** 
     * 獲取cpu信息   百分率
     *  
     * @return float efficiency 
     * @throws IOException 
     * @throws InterruptedException 
     */  
    public static float getCpuInfo(List<DataObject> list) throws IOException, InterruptedException { 
    	
        File file = new File("/proc/stat");
        BufferedReader br = new BufferedReader(new InputStreamReader(  
                new FileInputStream(file)));  
        StringTokenizer token = new StringTokenizer(br.readLine());  
        token.nextToken();  
        
        long user1 = Long.parseLong(token.nextToken());  
        long nice1 = Long.parseLong(token.nextToken());  
        long sys1 = Long.parseLong(token.nextToken());  
        long idle1 = Long.parseLong(token.nextToken());
        long iowait1 = Long.parseLong(token.nextToken());
        long irq1 = Long.parseLong(token.nextToken());
        long softirq1 = Long.parseLong(token.nextToken());
        
        Thread.sleep(1000);
  
        br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
        
        token = new StringTokenizer(br.readLine());  
        token.nextToken();
      
        long user2 = Long.parseLong(token.nextToken());  
        long nice2 = Long.parseLong(token.nextToken());  
        long sys2 = Long.parseLong(token.nextToken());  
        long idle2 = Long.parseLong(token.nextToken());
        long iowait2 = Long.parseLong(token.nextToken());
        long irq2 = Long.parseLong(token.nextToken());
        long softirq2 = Long.parseLong(token.nextToken());
        
        float totalCpu=(user2 + nice2 + sys2 + idle2 + iowait2 +irq2 +softirq2) - (user1 + nice1  
                + sys1 + idle1 + iowait1 +irq1 +softirq1);
        
        float usageCpu=(float) ((user2 + sys2 + nice2) - (user1 + sys1 + nice1))  
                / totalCpu ;
        
        usageCpu=(totalCpu-(idle2-idle1))/totalCpu;
        
        DataObject userData = new DataObject();
        userData.setClock(System.currentTimeMillis());
        userData.setKey("system.cpu.util[,user]");
        userData.setValue((user2-user1)/totalCpu*100 +"");
        list.add(userData);
        
        DataObject niceData = new DataObject();
        niceData.setClock(System.currentTimeMillis());
        niceData.setKey("system.cpu.util[,nice]");
        niceData.setValue((nice2-nice1)/totalCpu*100 +"");
        list.add(niceData);
        
        DataObject sysData = new DataObject();
        sysData.setClock(System.currentTimeMillis());
        sysData.setKey("system.cpu.util[,system]");
        sysData.setValue( (sys2-sys1)/totalCpu*100 +"");
        list.add(sysData);
        
        DataObject idleData = new DataObject();
        idleData.setClock(System.currentTimeMillis());
        idleData.setKey("system.cpu.util[,idle]");
        idleData.setValue( (idle2-idle1)/totalCpu*100 +"");
        list.add(idleData);
         
        DataObject iowaitData = new DataObject();
        iowaitData.setClock(System.currentTimeMillis());
        iowaitData.setKey("system.cpu.util[,iowait]");
        iowaitData.setValue( (iowait2-iowait1)/totalCpu*100 +"");
        list.add(iowaitData);
        
        DataObject irqData = new DataObject();
        irqData.setClock(System.currentTimeMillis());
        irqData.setKey("system.cpu.util[,interrupt]");
        irqData.setValue( (irq2-irq1)/totalCpu*100 +"");
        list.add(irqData);
        
        DataObject softirqData = new DataObject();
        softirqData.setClock(System.currentTimeMillis());
        softirqData.setKey("system.cpu.util[,softirq]");
        softirqData.setValue( (softirq2-softirq1)/totalCpu*100 +"");
        list.add(softirqData);        
        
        return 0.0f;
        
      }  
    
    /**
     * cpu 平均負載 百分率
     * 
     * @param list
     */
    public static void getCpuLoadAvg(List<DataObject> list){
    	  File file = new File("/proc/loadavg");
          BufferedReader br;
		try {
			
			br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
		    StringTokenizer token = new StringTokenizer(br.readLine());  
           
            DataObject oneMinuteLoad=new DataObject();
            oneMinuteLoad.setClock(System.currentTimeMillis());
            oneMinuteLoad.setKey("system.cpu.load[,avg1]");
            oneMinuteLoad.setValue(token.nextToken());
            list.add(oneMinuteLoad);
            
            DataObject fiveMinuteLoad=new DataObject();
            fiveMinuteLoad.setClock(System.currentTimeMillis());
            fiveMinuteLoad.setKey("system.cpu.load[,avg5]");
            fiveMinuteLoad.setValue(token.nextToken());
            list.add(fiveMinuteLoad);
            
            DataObject fifteenMinuteLoad=new DataObject();
            fifteenMinuteLoad.setClock(System.currentTimeMillis());
            fifteenMinuteLoad.setKey("system.cpu.load[,avg15]");
            fifteenMinuteLoad.setValue(token.nextToken());
            list.add(fifteenMinuteLoad);
       
		} catch (Exception e) {
			
			log.error("get cpu loadavg error:"+e.getMessage());
			log.error("get cpu loadavg error:"+e.getLocalizedMessage());
		}  
    }
    
    //單位是  byte
    /**
     * 網絡流量 IO  Byte
     * @param list
     * @return
     */
    public  static float getNetInfo(List<DataObject> list) {  
      
        float netUsage = 0.0f;  
        Map<String,Object>  mapNet=new HashMap<String,Object>();
        BufferedReader in1 = null;
        BufferedReader in2 = null; 
        try {
        	
        	File file = new File("/proc/net/dev");
            in1 = new BufferedReader(new InputStreamReader(  
                      new FileInputStream(file)));  
//            //第一次採集流量數據  
            long startTime = System.currentTimeMillis();  
            String line = null;  
            long inSize1 = 0, outSize1 = 0;
            in1.readLine();
            in1.readLine();
            //[face, |bytes, packets, errs, drop, fifo, frame, compressed, multicast|bytes, packets, errs, drop, fifo, colls, carrier, compressed]
         
            while((line=in1.readLine()) != null){
            	
                line = line.trim();
                
                String[] temp = line.split("\\s+");
                String eth_name=temp[0].substring(0,temp[0].lastIndexOf(":"));
                
                if(eth_name.equals("lo"))
                	continue;
                int _index=temp[0].lastIndexOf(":");
            
                if(temp[0].length() > _index+1){
                	inSize1 = Long.parseLong(temp[0].substring(temp[0].lastIndexOf(":")+1)); //Receive bytes,單位爲Byte  
                    outSize1 = Long.parseLong(temp[8]);//Transmit bytes,單位爲Byte  
                }else{
                	inSize1 = Long.parseLong(temp[1]);
                    outSize1 = Long.parseLong(temp[9]);//Transmit bytes,單位爲Byte  
                }
                long[] size={inSize1,outSize1};
                mapNet.put(eth_name, size);
             }     
            in1.close();
          
            try {  
                Thread.sleep(1000); 
            } catch (InterruptedException e) {  
                StringWriter sw = new StringWriter();
                e.printStackTrace(new PrintWriter(sw));  
            }  
            //第二次採集流量數據  
            long endTime = System.currentTimeMillis();
            in2 = new BufferedReader(new InputStreamReader(  
                    new FileInputStream(file)));  
            long inSize2 = 0 ,outSize2 = 0;  
            in2.readLine();
            in2.readLine();
            while((line=in2.readLine()) != null){
                line = line.trim();
                String[] temp = line.split("\\s+");
                String eth_name=temp[0].substring(0,temp[0].lastIndexOf(":"));
                if(eth_name.equals("lo"))
                	continue;
                
                int _index=temp[0].lastIndexOf(":");
            	
                if(temp[0].length() > _index+1){
                
                	inSize2 = Long.parseLong(temp[0].substring(temp[0].lastIndexOf(":")+1));  
                	outSize2 = Long.parseLong(temp[8]);
                }else{
                	inSize2 = Long.parseLong(temp[1]);
                    outSize2 = Long.parseLong(temp[9]);//Transmit bytes,單位爲Byte  
                	
                }
                long [] d =(long[]) mapNet.get(eth_name);
                long inNet=d[0];
                long outNet=d[1];
                
                DataObject  inNetData = new   DataObject();
                inNetData.setClock(System.currentTimeMillis());
                inNetData.setKey("net.if.in["+eth_name+"]");
                inNetData.setValue( (inSize2-inNet) +"");
                list.add(inNetData);
                
                DataObject  outNetData = new   DataObject();
                outNetData.setClock(System.currentTimeMillis());
                outNetData.setKey("net.if.out["+eth_name+"]");
                outNetData.setValue( (outSize2-outNet) + "");
                list.add(outNetData);
                
//              System.out.println(inSize2 + " - " + inNet + "=" + (inSize2-inNet)/128.0);   //除以128   單位KB    (換算成 bps    Kbps)
//              outNetData.setValue( (outSize2-outNet)*8 +"");  //乘以8   單位B
            }
            
            in2.close();
        } catch (IOException e) {
            StringWriter sw = new StringWriter();  
            e.printStackTrace(new PrintWriter(sw));  
            log.error("NetUsage發生InstantiationException. " + e.getMessage());  
            log.error(sw.toString());
        } finally{
        	try {
				if ( in1 != null ) in1.close();
				if (  in2 != null ) in2.close();
			} catch (IOException e) {
				log.info("IOException :" + e.getMessage());
			}
        }
        return netUsage;
    }
    
    /**
     * 獲取主機狀態信息   1 是正常  
     * 
     * @param list
     */
    public static void getHostStatus(List<DataObject> list){
    	
    	DataObject data = new DataObject();
    	data.setClock(System.currentTimeMillis());
    	data.setKey("agent.ping");
    	data.setValue("1");
    	list.add(data);
    	
    }
    
    public static List<DataObject>  get()  {
    	List<DataObject> list= new ArrayList<DataObject>();
    	//內存  cpu  網絡IO 磁盤IO
    	try{
    		
	    	LinuxSystemTool.getMemInfo(list);
	        LinuxSystemTool.getCpuInfo(list);
	        LinuxSystemTool.getCpuLoadAvg(list);
	        LinuxSystemTool.getNetInfo(list);
	        LinuxSystemTool.getDiskSpace(list);
	        LinuxSystemTool.getIOstats(list);
	        LinuxSystemTool.getHostStatus(list);
	        
    	}catch(Exception e){
    		log.error("exception:"+e.getMessage());
    	}
    	log.info(JSON.toJSONString(list, true));
    	
        return list;
    }  
    
//http://www.360doc.com/content/14/0603/14/14935022_383255906.shtml  推導公式
/* 
    8       0 sda 84369 44065 3313744 31078 72767 195050 2144912 56178 0 54484 87178
    8       1 sda1 804 823 6430 90 11 7 72 2 0 90 91
    8       2 sda2 82544 41372 3284186 30663 71229 162201 1869888 47523 0 48303 78111
    8       3 sda3 863 1870 21864 290 1527 32842 274952 8653 0 6547 8941
*/
    /**
     * 磁盤IO  單位Byte
     * 
     * @param list
     */
    public static void getIOstats(List <DataObject> list){
    	
    	File file = new File("/proc/diskstats");
        BufferedReader in1=null;
        BufferedReader in2=null;
        String line = null; 
    	try {
    		in1 = new BufferedReader(new InputStreamReader(  
			          new FileInputStream(file)));
			try {
				long tmp[]={0,0};
				while((line=in1.readLine()) != null){
					line = line.trim();
					String [] ss = line.split("\\s+");
					Pattern p = Pattern.compile("sd[a-z][0-9]\\d{0,}$|hd[a-z][0-9]\\d{0,}$");
					Matcher matcher = p.matcher(ss[2]);
					boolean flag=matcher.matches();
					if(ss[2].contains("loop") || ss[2].contains("ram") || flag)
						continue;

					tmp[0]+=Long.parseLong(ss[5]);
					tmp[1]+=Long.parseLong(ss[9]);
					
				}
				
				Thread.sleep(1000);
				
				in2 = new BufferedReader(new InputStreamReader(  
				          new FileInputStream(file)));
				
				long[] tmp2={0,0};
				
				while((line=in2.readLine()) != null){
					line = line.trim();
					String [] ss = line.split("\\s+");
					
					Pattern p = Pattern.compile("sd[a-z][0-9]\\d{0,}$|hd[a-z][0-9]\\d{0,}$");
					Matcher matcher = p.matcher(ss[2]);
					boolean flag=matcher.matches();
					
					if( ss[2].contains("loop") || ss[2].contains("ram") || flag)
						continue;
					
					long rd_sectors2 = Long.parseLong(ss[5]);
					long wr_sectors2 = Long.parseLong(ss[9]);
					
					tmp2[0]+=rd_sectors2;
					tmp2[1]+=wr_sectors2;
					
				}
				
				long rd_sector = tmp2[0]-tmp[0];
				long wr_sector = tmp2[1]-tmp[1];
				
				DataObject readData = new DataObject();
				readData.setClock(System.currentTimeMillis());
				readData.setKey("vfs.dev.read[,,avg1]");
				readData.setValue(rd_sector *512 +"");
				list.add(readData);
				
				DataObject writeData = new DataObject();
				writeData.setClock(System.currentTimeMillis());
				writeData.setKey("vfs.dev.write[,,avg1]");
				writeData.setValue(wr_sector *512 +"");
				list.add(writeData);
				
				log.info(JSON.toJSONString(list,true));
				//一個扇區是 512 Byte；re_sector wr_sector是扇區數，換算成KB，要除以2；1KB=2*512Bytess
				//System.out.println(JSON.toJSONString(list,true));
				
			} catch (Exception e) {
				log.error("diskstats error:"+e.getMessage());
			}finally{
				
				try {
					if ( in1 != null ) in1.close();
					if (  in2 != null ) in2.close();
				} catch (IOException e) {
					log.info("IOException :" + e.getMessage());
				}
			}
		} catch (FileNotFoundException e) {
			
			log.error("diskstats exception:"+e.getMessage());
			
		}
    }
    
    /**
     * 磁盤總量 單位 Byte
     * 
     * @param list
     */
    public static  void getDiskSpace( List <DataObject> list) {
    	File file = new File("/etc/mtab");
        BufferedReader in1 = null;
        String line = null;

      /*
       * /dev/sda2 / ext4 rw 0 0
		proc /proc proc rw 0 0
		sysfs /sys sysfs rw 0 0
		devpts /dev/pts devpts rw,gid=5,mode=620 0 0
		tmpfs /dev/shm tmpfs rw 0 0
		/dev/sda1 /boot ext4 rw 0 0
		/dev/sdb5 /data/logic ext3 rw 0 0
		/dev/sdb1 /data/primary ext4 rw 0 0
		none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0
		sunrpc /var/lib/nfs/rpc_pipefs rpc_pipefs rw 0 0
		gvfs-fuse-daemon /root/.gvfs fuse.gvfs-fuse-daemon rw,nosuid,nodev 0 0
		/dev/sr0 /media/VMware\040Tools iso9660 r
	   *   一個目錄可以掛載多個分區，（一個分區掛在到多個目錄中沒有意義）
         * */
        try {
        	in1 = new BufferedReader(new InputStreamReader(  
			          new FileInputStream(file)));
		
			while((line=in1.readLine()) != null){
				line = line.trim();
				String [] ss = line.split("\\s+");
				File ff=new File(ss[1]);
				
				if(ss[2].equals("xfs") || ss[2].contains("ext") || ss[2].equals("btrfs")){
					//long usdSpace=(long) (ff.getUsableSpace());
					long freeSpace=(long)ff.getFreeSpace();
					long totalSpace=(long) (ff.getTotalSpace());
					
					DataObject totalSpaceData = new DataObject();
					totalSpaceData.setClock(System.currentTimeMillis());
					totalSpaceData.setKey("vfs.fs.size["+ss[1]+",total]");
					totalSpaceData.setValue(totalSpace +"");
					list.add(totalSpaceData);
					
					DataObject usedSpaceData = new DataObject();
					usedSpaceData.setClock(System.currentTimeMillis());
					usedSpaceData.setKey("vfs.fs.size["+ss[1]+",used]");
					usedSpaceData.setValue(totalSpace-freeSpace +"");
					list.add(usedSpaceData);
					
					DataObject typeFileSystemData = new DataObject();
					typeFileSystemData.setClock(System.currentTimeMillis());
					typeFileSystemData.setKey("fs_type_"+ss[1]);
					typeFileSystemData.setValue(ss[2]);
					list.add(typeFileSystemData);
					
					DataObject  pusedData = new DataObject();
					pusedData.setClock(System.currentTimeMillis());
					pusedData.setKey("vfs.fs.size["+ ss[1] +",pused]");
					pusedData.setValue( (totalSpace-freeSpace)/(float)totalSpace +"" );
					list.add(pusedData);
					
				}
				//map.put(ss[1], obj);
		}
			log.info(JSON.toJSONString(list,true)); 
			//System.out.print(JSON.toJSONString(list,true));
		} catch (Exception e1) {
			
			log.info("Exception:"+e1.getMessage());
			
		}finally{
			
			if(in1 != null){
				try {
					
					in1.close();
					
				} catch (IOException e) {
				
					log.error("IOexception :"+e.getMessage());
				}
			}
		}
    }
    
    
	public static void main(String[] args) throws Exception { 
    	String tmp="";
    	if(args.length != 0){
    		tmp=args[0];
    	}
    	 
//    	tmp="diskIO";
//    	//內存
    	while(true){
 
    	//內存（讀文件）-》proc/meminfo
    	//cpu（讀文件）-》/proc/stat 		
    	//網絡(讀文件)-》/proc/net/dev      
    	//磁盤-》執行命令
    	/*
        List<DataObject>  list= new ArrayList<DataObject>();
    	if(tmp.equals("mem") || "".equals(tmp)){
    		   LinuxSystemTool.getMemInfo(list);
    		
    	}
    	if(tmp.equals("cpu") || "".equals(tmp)){
    		  LinuxSystemTool.getCpuInfo(list);
    		  LinuxSystemTool.getCpuLoadAvg(list);
    	}
    	if(tmp.equals("net") || "".equals(tmp)){
    		  LinuxSystemTool.getNetInfo(list);
    		 
    	}
    	if(tmp.equals("diskIO" )|| "".equals(tmp) ){
    		 LinuxSystemTool.getIOstats(list);
    	}
    	
    	  //磁盤IO  執行命令；
    	if(tmp.equals("disk") || "".equals(tmp) ){
    		  LinuxSystemTool.getDiskSpace(list);
//    		  System.out.println(JSON.toJSONString(list,true));
//    		  break;
    	}
    	*/
    	
    	 List<DataObject>  list= new ArrayList<DataObject>();
    	 LinuxSystemTool.getDiskSpace(list);
    	
    	
    	
    	 System.out.println(JSON.toJSONString(list,true));
    	 break;
    	}
    }  
}  

參考博客：

http://www.makaidong.com/IT%E5%8D%9A%E5%AE%A2%E5%9B%AD/29313.shtml  硬盤原理與IO吞吐量計算

http://avery-leo.iteye.com/blog/298724  獲取cpu，網絡，磁盤資源的源碼參考

http://www.360doc.com/content/14/0603/14/14935022_383255906.shtml linux內核源碼解析

如果通過採集器的方式每20s採集一次數據，那隻能獲取20s前一刻的IO速率，不具有代表性。如果這20s內有數據拷貝，IO速率信息也是統計不到的。

Cpunet IO 都會有數據丟失的問題