获取Linux系统信息工具类

导包

        <dependency>
            <groupId>com.github.oshigroupId>
            <artifactId>oshi-coreartifactId>
            <version>6.4.0version>
        dependency>

全局格式化时间

  jackson:
    # 格式化全局时间字段 年-月-天 时：分：秒
    date-format: yyyy-MM-dd HH:mm:ss
    # 指定时间区域类型 东8区时区 既北京时间
    time-zone: GMT+8

DiskInfo实体类

import lombok.Data;

/**
 * 磁盘信息封装类
 *
 */
@Data
public class DisksInfo {

    /**
     * 文件系统的挂载点
     */
    private String dirName;

    /**
     * 文件系统名称
     */
    private String sysTypeName;

    /**
     * 文件系统的类型(FAT，NTFS，etx2，ext4等)
     */
    private String typeName;

    /**
     * 总大小
     */
    private long total;

    /**
     * 剩余大小
     */
    private long free;

    /**
     * 已经使用量
     */
    private long used;

    /**
     * 资源的使用率
     */
    private String usage;
}

NetworkInfo实体类

import lombok.Data;

import java.util.List;

/**
 * 网卡信息包装类
 *
 */
@Data
public class NetworkInfo {

    /**
     * ipv4地址
     */
    private String ipv4Address;

    /**
     * ipv6地址
     */
    private String ipv6Address;

    /**
     * mac地址
     */
    private String macAddress;

    /**
     * 网卡名称
     */
    private String networkName;

    /**
     * 发送数据量
     */
    private long send;

    /**
     * 接受数据量
     */
    private long accept;

    /**
     * 网卡时间戳
     */
    private long timeStamp;

    /**
     * 子网掩码
     */
    private String subnetMask;

    /**
     * 前缀长度
     */
    private String prefixLength;

    /**
     * 首选dns服务器地址
     */
    private String preferredDnsServer;

    /**
     * 备选dns服务器地址
     */
    private String alternateDnsServer;

    /**
     * IPV4网关地址
     */
    private String ipv4Gateway;

    /**
     * IPV6网关地址
     */
    private String ipv6Gateway;




}

OSInfo实体类

import lombok.Data;

import java.util.Date;
import java.util.List;

/**
 * 系统信息
 *
 */
@Data
public class OSInfo {

    /**
     * 系统
     */
    private String os;

    /**
     * 系统架构
     */
    private String osArch;

    /**
     * java版本
     */
    private String javaVersion;

    /**
     * 工作目录
     */
    private String userDir;

    /**
     * cpu核心数
     */
    private int cpuCount;

    /**
     * 主机host
     */
    private String host;

    /**
     * 主机名称
     */
    private String hostName;

    /**
     * 系统时间
     */
    private Date sysTime;

    /**
     * 产品
     */
    private String model;

    /**
     * 序列号
     */
    private String serialNumber;

    /**
     * 系统已启动时间
     */
    private String bootTime;

    /**
     * 系统内存使用率
     */
    private String usage;

    /**
     * 磁盘信息
     */
    private List<DisksInfo> disksList;

}

OSRuntimeInfo

import com.yuyin.ippbx.vo.systeminfo.DisksInfo;
import com.yuyin.ippbx.vo.systeminfo.NetworkInfo;
import lombok.Data;

import java.util.List;

/**
 * 系统运行时信息
 *
 */
@Data
public class OSRuntimeInfo {

    /**
     * 时刻
     */
    private String timestamp;

    /**
     * cpu使用率
     */
    private double cpuUsage;

    /**
     * cpu基准速度（GHz）
     */
    private String cpuMaxFreq;

    /**
     * cpu当前速度（GHz）
     */
    private String cpuCurrentFreq;

    /**
     * 总内存
     */
    private long totalMemory;

    /**
     * 使用内存
     */
    private long usedMemory;

    /**
     * 可用虚拟总内存
     */
    private long swapTotalMemory;

    /**
     * 已用虚拟内存
     */
    private long swapUsedMemory;

    /**
     * 磁盘信息
     */
    private List<DisksInfo> disksList;

    /**
     * 磁盘读取速率（Kb/s）
     */
    private Double diskReadRate;

    /**
     * 磁盘写入速率（Kb/s）
     */
    private Double diskWriteRate;

    /**
     * 网卡信息
     */
    private List<NetworkInfo> networkList;

}

获取信息工具类

import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.unit.DataUnit;
import cn.hutool.core.util.StrUtil;
import cn.hutool.system.oshi.OshiUtil;
import com.yuyin.ippbx.vo.systeminfo.DisksInfo;
import com.yuyin.ippbx.vo.systeminfo.NetworkInfo;
import com.yuyin.ippbx.vo.systeminfo.OSInfo;
import com.yuyin.ippbx.vo.systeminfo.OSRuntimeInfo;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import oshi.PlatformEnum;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.hardware.NetworkIF;
import oshi.software.os.FileSystem;
import oshi.software.os.NetworkParams;
import oshi.software.os.OSFileStore;
import oshi.software.os.OperatingSystem;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

/**
 * 系统信息获取工具类
 * 1.操作系统信息
 * 2.系统cpu使用信息
 * 3.系统内存信息
 * 4.系统卡流量信息
 * 5.磁盘使用量信息
 */
@Slf4j
public class SystemInfoUtil {

    private static SystemInfo systemInfo;

    private static HardwareAbstractionLayer abstractionLayer;

    private static OperatingSystem operatingSystem;

    private static CentralProcessor centralProcessor;

    private static GlobalMemory globalMemory;

    private static long[] oldTicks;

    private static Map<String, Long[]> networkInfoMap;

    private static List<NetworkIF> networkIFList;

    private static DecimalFormat df = new DecimalFormat("0.00");

    private SystemInfoUtil() {
    }


    static {
        try {
            systemInfo = new SystemInfo();
            abstractionLayer = systemInfo.getHardware();
            operatingSystem = systemInfo.getOperatingSystem();
            centralProcessor = abstractionLayer.getProcessor();
            globalMemory = abstractionLayer.getMemory();
            oldTicks = new long[CentralProcessor.TickType.values().length];
            networkInfoMap = new ConcurrentHashMap<>();
            networkIFList = getNetwork();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    enum NetworkType {
        /**
         * 当前网卡时间戳
         */
        TIME_STAMP(0),
        /**
         * 网卡总发送量
         */
        SEND(1),
        /**
         * 网卡总接收量
         */
        ACCEPT(2);
        private int index;

        NetworkType(int value) {
            this.index = value;
        }

        public int getIndex() {
            return index;
        }
    }

    /**
     * 获取磁盘列表信息
     *
     * @return
     */
    public static List<DisksInfo> getDisksList() {
        FileSystem fileSystem = operatingSystem.getFileSystem();
        List<OSFileStore> fileStores = fileSystem.getFileStores();
        List<DisksInfo> list = new ArrayList<>();
        for (int i = 0; i < fileStores.size(); i++) {
            OSFileStore osFileStore = fileStores.get(i);
            DisksInfo disksInfo = new DisksInfo();
            disksInfo.setDirName(osFileStore.getMount());
            String name = osFileStore.getName();
            disksInfo.setSysTypeName(name);
            disksInfo.setTypeName(osFileStore.getType());
            long total = osFileStore.getTotalSpace();
            long free = osFileStore.getUsableSpace();
            long used = total - free;
            if (used < 0) {
                // 有的挂载盘获取到的 free比total还大 不知是否是方法问题
                continue;
            }
            disksInfo.setTotal(total);
            disksInfo.setFree(free);
            disksInfo.setUsed(used);
            if (total != 0) {
                disksInfo.setUsage(formatRate(Double.parseDouble(df.format((double) used / total))));
            }
            list.add(disksInfo);
        }
        return list;
    }

    /**
     * 获取网络接口NetworkIF对象列表
     *
     * @return
     */
    private static List<NetworkIF> getNetwork() {
        List<NetworkIF> list = new ArrayList<>();
        List<NetworkIF> networkIFs = abstractionLayer.getNetworkIFs();
        for (int i = 0; i < networkIFs.size(); i++) {
            NetworkIF networkIF = networkIFs.get(i);
            if (!networkIF.isKnownVmMacAddr()) {
                if (networkIF.getMacaddr() != null && networkIF.getIPv4addr().length > 0
                        && networkIF.getIPv6addr().length > 0) {
                    if (!networkInfoMap.containsKey(networkIF.getMacaddr())) {
                        networkIF.updateAttributes();
                        Long[] data = new Long[]{networkIF.getTimeStamp(), networkIF.getBytesSent(), networkIF.getBytesRecv()};
                        networkInfoMap.put(networkIF.getMacaddr(), data);
                    }
                    list.add(networkIF);
                }
            }
        }
        return list;
    }

    /**
     * 网卡实际的传输速率受多方面影响，具体如下：
     * 1、硬盘的读写（I/O）速度达不到。
     * 2、网卡本身性能差。
     * 3、交换机/（HUB）性能差。
     * 4、通讯线路条件质量差。
     * 5、网络性能差。
     * 

     * 一般情况下：
     * 网络条件比较好的网络利用率100Mbits的一般为：1/8(此方法默认)
     * 网络及各方面条件差的利用率一般为：1/12
     */
    public static List<NetworkInfo> getNetworkInfo() throws UnknownHostException {
        networkIFList = getNetwork();
        List<NetworkInfo> list = new ArrayList<>();
        for (int i = 0; i < networkIFList.size(); i++) {
            NetworkIF networkIF = networkIFList.get(i);
            if (networkIF.updateAttributes()) {
                if (networkIF.getIPv4addr().length > 0 && networkIF.getIPv6addr().length > 0) {
                    NetworkInfo networkInfo = new NetworkInfo();
                    networkInfo.setIpv4Address(networkIF.getIPv4addr()[0]);
                    networkInfo.setIpv6Address(networkIF.getIPv6addr()[0]);
                    Short prefixLength = networkIF.getSubnetMasks()[0];
                    // 转换格式
                    String submask = convertSubMask(prefixLength);
                    networkInfo.setSubnetMask(submask);
                    // 获取mac地址
                    networkInfo.setMacAddress(networkIF.getMacaddr());
                    // 获取网络名称
                    networkInfo.setNetworkName(networkIF.getName());
                    // 获取网络配置参数：dns || 默认网关
                    NetworkParams networkParams = operatingSystem.getNetworkParams();
                    // dns
                    String[] dnsServers = networkParams.getDnsServers();
                    List<String> strings = Arrays.asList(dnsServers);
                    if (!strings.isEmpty()){
                        if (strings.get(0) != null){
                            // 首选dns服务器
                            networkInfo.setPreferredDnsServer(strings.get(0));
                        }
                        if (strings.get(1) != null){
                            // 备选dns服务器
                            networkInfo.setAlternateDnsServer(strings.get(1));
                        }
                    }
                    // 网关地址
                    networkInfo.setIpv4Gateway(networkParams.getIpv4DefaultGateway());
                    networkInfo.setIpv6Gateway(networkParams.getIpv6DefaultGateway());
                    networkInfo.setPrefixLength(String.valueOf(networkIF.getPrefixLengths()[0]));
//                    System.out.println("display"+networkIF.getDisplayName());

                    //计算
                    Long[] oldData = networkInfoMap.get(networkIF.getMacaddr());
                    long time = oldData[NetworkType.TIME_STAMP.getIndex()] - networkIF.getTimeStamp();
                    if (time == 0) {
                        continue;
                    }
                    long send = (oldData[NetworkType.SEND.getIndex()] - networkIF.getBytesSent()) * 8 / time * 1000;
                    long accept = (oldData[NetworkType.ACCEPT.getIndex()] - networkIF.getBytesRecv()) * 8 / time * 1000;
                    Long[] newData = new Long[]{networkIF.getTimeStamp(), networkIF.getBytesSent(), networkIF.getBytesRecv()};
                    networkInfoMap.put(networkInfo.getMacAddress(), newData);

                    //对象赋值
                    networkInfo.setTimeStamp(networkIF.getTimeStamp());
                    networkInfo.setSend(send);
                    networkInfo.setAccept(accept);
                    list.add(networkInfo);
                }
            }

        }
        return list;
    }

    /**
     * 子网掩码转换格式
     */
    public static String convertSubMask(short prflen){
        int shft = 0xffffffff<<(32-prflen);
        int oct1 = ((byte) ((shft&0xff000000)>>24)) & 0xff;
        int oct2 = ((byte) ((shft&0x00ff0000)>>16)) & 0xff;
        int oct3 = ((byte) ((shft&0x0000ff00)>>8)) & 0xff;
        int oct4 = ((byte) (shft&0x000000ff)) & 0xff;
        String submask = oct1+"."+oct2+"."+oct3+"."+oct4;
        return submask;
    }

    /**
     * 获取系统运行信息
     *
     * @return
     * @throws InterruptedException
     */
    public static OSRuntimeInfo getOSRuntimeInfo() throws InterruptedException, UnknownHostException {
        OSRuntimeInfo osRuntimeInfo = new OSRuntimeInfo();
        osRuntimeInfo.setTimestamp(DateUtil.now());
        //cpu使用率
        osRuntimeInfo.setCpuUsage(getCpuRate());
        //cpu基准速度（GHz）
        osRuntimeInfo.setCpuMaxFreq(df.format(centralProcessor.getMaxFreq() / 1000000000.0) + " GHz");
        //cpu当前速度（GHz）
        long[] currentFreq = centralProcessor.getCurrentFreq();
        long avg = Arrays.stream(currentFreq).sum() / currentFreq.length;
        osRuntimeInfo.setCpuCurrentFreq(df.format(avg / 1000000000.0) + " GHz");
        //系统内存总量
        osRuntimeInfo.setTotalMemory(globalMemory.getTotal());
        //系统使用量
        osRuntimeInfo.setUsedMemory(globalMemory.getTotal() - globalMemory.getAvailable());
        //可用虚拟总内存
        osRuntimeInfo.setSwapTotalMemory(globalMemory.getVirtualMemory().getSwapTotal());
        //已用虚拟内存
        osRuntimeInfo.setSwapUsedMemory(globalMemory.getVirtualMemory().getSwapUsed());
        //磁盘信息
        osRuntimeInfo.setDisksList(getDisksList());
        //磁盘读取速率
        Map<String, Double> diskIo = getDiskIo();
        double diskReadRate = diskIo.get("diskReadRate");
        osRuntimeInfo.setDiskReadRate(diskReadRate);
        //磁盘写入速率
        double diskWriteRate = diskIo.get("diskWriteRate");
        osRuntimeInfo.setDiskWriteRate(diskWriteRate);
        //网卡信息
        osRuntimeInfo.setNetworkList(getNetworkInfo());
        return osRuntimeInfo;
    }

    public static OSInfo getSystemInfo() throws UnknownHostException, InterruptedException {
        Properties props = System.getProperties();
        String model = OshiUtil.getHardware().getComputerSystem().getModel();
        String serialNumber = OshiUtil.getHardware().getComputerSystem().getSerialNumber();
        OSInfo osInfo = new OSInfo();
        //操作系统
        osInfo.setOs(props.getProperty("os.name"));
        //系统架构
        osInfo.setOsArch(props.getProperty("os.arch"));
        //java版本
        osInfo.setJavaVersion(props.getProperty("java.version"));
        //工作目录
        osInfo.setUserDir(props.getProperty("user.dir"));
        //CPU核数
        osInfo.setCpuCount(centralProcessor.getLogicalProcessorCount());
        // 系统时间
        osInfo.setSysTime(DateUtil.date());
        // 产品
        osInfo.setModel(model);
        // 版本号
        osInfo.setSerialNumber(serialNumber);
        //主机信息
        try {
            InetAddress address = InetAddress.getLocalHost();
            osInfo.setHost(address.getHostAddress());
            osInfo.setHostName(address.getHostName());
        } catch (UnknownHostException e) {
            log.error("主机信息获取失败");
        }
        //系统已启动时间
        String runTime = "";
        if (StrUtil.isNotEmpty(getBootTime())) {
            DateTime start = DateUtil.parse(getBootTime(), DatePattern.NORM_DATETIME_PATTERN);
            runTime = DateUtil.formatBetween(start, DateUtil.date());
        }
        osInfo.setBootTime(runTime);
        long total = globalMemory.getTotal();
        long used = globalMemory.getTotal() - globalMemory.getAvailable();
        double usage = used * 1.0 / total;
        // 系统内存使用率
        osInfo.setUsage(formatRate(usage));
//        log.info("usage: " + String.valueOf(usage));
//        log.info("format usage: " + String.valueOf(formatRate(usage)));
        osInfo.setDisksList(getDisksList());
        return osInfo;
    }

    @Test
    void testPlatformEnum() throws Exception {
        assertThat("Unsupported OS", SystemInfo.getCurrentPlatform(), is(not(PlatformEnum.UNKNOWN)));
        // Exercise the main method
        main(null);
    }


    public static void main(String[] args) throws Exception {

        //系统信息
        System.out.println("-----------系统信息-----------");
        OSInfo osInfo = getSystemInfo();
        System.out.println("操作系统："+ osInfo.getOs());
        System.out.println("系统架构："+ osInfo.getOsArch());
        System.out.println("Java版本："+ osInfo.getJavaVersion());
        System.out.println("工作目录："+ osInfo.getUserDir());
        System.out.println("cpu核心数："+ osInfo.getCpuCount());
        System.out.println("主机host："+ osInfo.getHost());
        System.out.println("主机名称："+ osInfo.getHostName());
        String bootTime = osInfo.getBootTime();
//        String runTime = "";
//        if (StrUtil.isNotEmpty(bootTime)) {
//            DateTime start = DateUtil.parse(bootTime, DatePattern.NORM_DATETIME_PATTERN);
//            runTime = DateUtil.formatBetween(start, DateUtil.date());
//        }
        System.out.println("系统正常运行时长："+ bootTime);
        //运行时信息
        System.out.println("-----------运行时信息-----------");
        OSRuntimeInfo osRuntimeInfo = getOSRuntimeInfo();
        //1.CPU信息
        System.out.println("------cpu信息------");
        System.out.println("cpu使用率：" + formatRate(osRuntimeInfo.getCpuUsage()));
        System.out.println("cpu基准速度：" + osRuntimeInfo.getCpuMaxFreq());
        System.out.println("cpu速度：" + osRuntimeInfo.getCpuCurrentFreq());
        //2.内存信息
        System.out.println("------内存信息------");
        //系统内存总量
        long total = osRuntimeInfo.getTotalMemory();
        long used = osRuntimeInfo.getUsedMemory();
        double usage = used * 1.0 / total;
        System.out.println("系统内存总量：" + total + " -> " + formatData(total));
        System.out.println("系统内存使用量：" + used + " -> " + formatData(used));
        System.out.println("系统内存使用率：" + formatRate(usage));
        //可用虚拟总内存
        long swapTotal = osRuntimeInfo.getSwapTotalMemory();
        //已用虚拟内存
        long swapUsed = osRuntimeInfo.getSwapUsedMemory();
        System.out.println("可用虚拟总内存(swap)：" + swapTotal + " -> " + formatData(swapTotal));
        System.out.println("虚拟内存使用量(swap)：" + swapUsed + " -> " + formatData(swapUsed));
        //3.磁盘信息
        System.out.println("------磁盘信息------");
        System.out.println("磁盘读取速度：" + osRuntimeInfo.getDiskReadRate() + "Kb/s");
        System.out.println("磁盘写入速度：" + osRuntimeInfo.getDiskWriteRate() + "Kb/s");
        List<DisksInfo> disksList = osRuntimeInfo.getDisksList();
        for (DisksInfo disksInfo : disksList) {
            System.out.println("挂载点：" + disksInfo.getDirName());
            System.out.println("文件系统名称：" + disksInfo.getSysTypeName());
            System.out.println("文件系统类型：" + disksInfo.getTypeName());
            System.out.println("磁盘总量：" + disksInfo.getTotal() + " -> " + formatData(disksInfo.getTotal()));
            System.out.println("磁盘使用量：" + disksInfo.getUsed() + " -> " + formatData(disksInfo.getUsed()));
            System.out.println("磁盘剩余量：" + disksInfo.getFree() + " -> " + formatData(disksInfo.getFree()));
            System.out.println("磁盘使用率：" + disksInfo.getUsage());
        }
        //4.网卡网络信息
        List<NetworkInfo> netList = getNetworkInfo();
        System.out.println("------网卡网络信息------");
        for (NetworkInfo networkInfo : netList) {
            System.out.println("ipv4地址："+networkInfo.getIpv4Address());
            System.out.println("ipv6地址："+networkInfo.getIpv6Address());
            System.out.println("mac地址："+networkInfo.getMacAddress());
            System.out.println("网卡名称："+networkInfo.getNetworkName());
            System.out.println("子网掩码："+networkInfo.getSubnetMask());
            System.out.println("前缀长度："+networkInfo.getPrefixLength());
            System.out.println("首选dns服务器："+networkInfo.getPreferredDnsServer());
            System.out.println("备选dns服务器："+networkInfo.getAlternateDnsServer());
            System.out.println("ipv4默认网关："+networkInfo.getIpv4Gateway());
            System.out.println("ipv6默认网关："+networkInfo.getIpv6Gateway());
            double send = networkInfo.getSend() / 1024.0;
            double accept = networkInfo.getAccept() / 1024.0;
            System.out.println("上传速度↑："+String.format("%.1f%s", send, "Kbps"));
            System.out.println("下载速度↓："+String.format("%.1f%s", accept, "Kbps"));
            System.out.println("=======================");
        }
    }


    /**
     * @return cpuRate cpu使用率
     * @throws InterruptedException
     */
    public static double getCpuRate() throws InterruptedException {
        CentralProcessor processor = OshiUtil.getHardware().getProcessor();
        long[] prevTicks = processor.getSystemCpuLoadTicks();
        // 睡眠1s
        TimeUnit.SECONDS.sleep(1);
        long[] ticks = processor.getSystemCpuLoadTicks();
        long nice = ticks[CentralProcessor.TickType.NICE.getIndex()]
                - prevTicks[CentralProcessor.TickType.NICE.getIndex()];
        long irq = ticks[CentralProcessor.TickType.IRQ.getIndex()]
                - prevTicks[CentralProcessor.TickType.IRQ.getIndex()];
        long softirq = ticks[CentralProcessor.TickType.SOFTIRQ.getIndex()]
                - prevTicks[CentralProcessor.TickType.SOFTIRQ.getIndex()];
        long steal = ticks[CentralProcessor.TickType.STEAL.getIndex()]
                - prevTicks[CentralProcessor.TickType.STEAL.getIndex()];
        long cSys = ticks[CentralProcessor.TickType.SYSTEM.getIndex()]
                - prevTicks[CentralProcessor.TickType.SYSTEM.getIndex()];
        long user = ticks[CentralProcessor.TickType.USER.getIndex()]
                - prevTicks[CentralProcessor.TickType.USER.getIndex()];
        long iowait = ticks[CentralProcessor.TickType.IOWAIT.getIndex()]
                - prevTicks[CentralProcessor.TickType.IOWAIT.getIndex()];
        long idle = ticks[CentralProcessor.TickType.IDLE.getIndex()]
                - prevTicks[CentralProcessor.TickType.IDLE.getIndex()];
        long totalCpu = user + nice + cSys + idle + iowait + irq + softirq + steal;
        double d = 1.0 - (idle * 1.0 / totalCpu);
        return Double.parseDouble(df.format(d));
    }

    /**
     * 获取系统启动时间
     *
     * @return
     */
    public static String getBootTime() {
        String uptime = "";
        String os = System.getProperty("os.name").toLowerCase();
        try {
            if (os.contains("win")) {
                Process uptimeProc = Runtime.getRuntime().exec("net statistics Workstation");
                BufferedReader in = new BufferedReader(new InputStreamReader(uptimeProc.getInputStream(), Charset.forName("GBK")));
                String line;
                while ((line = in.readLine()) != null) {
                    if (line.startsWith("Statistics since")) {
                        SimpleDateFormat format = new SimpleDateFormat("'Statistics since' yyyy/MM/dd HH:mm:ss");
                        Date bootTime = format.parse(line);
                        uptime = DateUtil.format(bootTime, DatePattern.NORM_DATETIME_PATTERN);
                        break;
                    } else if (line.startsWith("统计数据开始于")) {
                        SimpleDateFormat format = new SimpleDateFormat("'统计数据开始于' yyyy/MM/dd HH:mm:ss");
                        Date bootTime = format.parse(line);
                        uptime = DateUtil.format(bootTime, DatePattern.NORM_DATETIME_PATTERN);
                        break;
                    }
                }
            } else if (os.contains("mac") || os.contains("nix") || os.contains("nux") || os.contains("aix")) {
                Process uptimeProc = Runtime.getRuntime().exec("uptime -s");
                BufferedReader in = new BufferedReader(new InputStreamReader(uptimeProc.getInputStream()));
                String line = in.readLine();
                if (line != null) {
                    uptime = line;
                }
            }
        } catch (Exception e) {
            log.error("获取系统启动时间异常: {}", e.getMessage());
        }
        return uptime;
    }

    /**
     * 获取磁盘读写速度（Kb/秒）
     *
     * @return
     */
    public static Map<String, Double> getDiskIo() {
        Map<String, Double> map = new HashMap<>();
        StringBuilder sb = new StringBuilder();
        String os = System.getProperty("os.name").toLowerCase();
        try {
            if (os.contains("mac") || os.contains("nix") || os.contains("nux") || os.contains("aix")) {
                Process pos = Runtime.getRuntime().exec("iostat -d 1 2");
                pos.waitFor();
                InputStreamReader isr = new InputStreamReader(pos.getInputStream());
                LineNumberReader lnr = new LineNumberReader(isr);
                String line;
                while ((line = lnr.readLine()) != null) {
                    sb.append(line).append("\n");
                }
            }
            String info = sb.toString();
            if (StrUtil.isEmpty(info)) {
                map.put("diskReadRate", 0D);
                map.put("diskWriteRate", 0D);
                return map;
            }
            String[] data = info.split("\n");
            for (int i = 7; i < data.length; i++) {
                String[] numdata = data[i].split(" +");
                String devName = numdata[0];
                double diskReadRate = Double.parseDouble(numdata[2]); //磁盘读数据速率
                double diskWriteRate = Double.parseDouble(numdata[3]); //磁盘写数据速率
                //这里简单统计，只需要统计一个就行，直接break结束循环
                map.put("diskReadRate", diskReadRate);
                map.put("diskWriteRate", diskWriteRate);
                break;
            }
        } catch (Exception e) {
            map.put("diskReadRate", 0D);
            map.put("diskWriteRate", 0D);
            log.error("获取磁盘传输速度异常: {}", e.getMessage());
        }
        return map;
    }

    /**
     * 格式化输出百分比
     *
     * @param rate 待格式化数据
     *
     * 
     *     0.1234   -> 12.34%
     *     1.2      -> 120%
     * 
     * @return
     */
    public static String formatRate(double rate) {
//        return new DecimalFormat("#.##%").format(rate);
        return new DecimalFormat("0.00").format(rate*100);
    }

    /**
     * 格式化输出大小 B/KB/MB...
     *
     * @param size 字节大小
     * @return
     */
    public static String formatData(long size) {
        if (size <= 0L) {
            return "0B";
        } else {
            int digitGroups = Math.min(DataUnit.UNIT_NAMES.length - 1, (int) (Math.log10((double) size) / Math.log10(1024.0D)));
            return (new DecimalFormat("#,##0.##")).format((double) size / Math.pow(1024.0D, (double) digitGroups)) + " " + DataUnit.UNIT_NAMES[digitGroups];
        }
    }
}