查询电脑配置：CPU信息、内存信息、服务器信息、Java虚拟机、磁盘信息。

最新推荐文章于 2024-01-02 09:15:04 发布
最新推荐文章于 2024-01-02 09:15:04 发布
阅读量409 收藏
点赞数
分类专栏： 有趣的功能实现 文章标签： java 服务器 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XuDream/article/details/125348235
版权

一、实现效果

1. 页面效果
在这里插入图片描述
2. 返回结果

{
    "msg": "操作成功",
    "code": 200,
    "data": {
        "cpu": {
            "cpuNum": 4,
            "total": 412400.0,
            "sys": 13.99,
            "used": 85.26,
            "wait": 0.0,
            "free": 0.0
        },
        "mem": {
            "total": 19.88,
            "used": 14.26,
            "free": 5.62,
            "usage": 71.73
        },
        "jvm": {
            "total": 34.33,
            "max": 247.5,
            "free": 11.0,
            "version": "1.8.0_73",
            "home": "D:\\JDK\\jdk\\jdk1.8.0_73\\jre",
            "name": "Java HotSpot(TM) Client VM",
            "startTime": "2022-06-18 15:52:27",
            "usage": 67.95,
            "used": 23.33,
            "inputArgs": "[-XX:TieredStopAtLevel=1, -Xverify:none, -Dspring.output.ansi.enabled=always, -Dcom.sun.management.jmxremote, -Dspring.jmx.enabled=true, -Dspring.liveBeansView.mbeanDomain, -Dspring.application.admin.enabled=true, -javaagent:C:\\Program Files\\JetBrains\\IntelliJ IDEA 2020.1.1\\lib\\idea_rt.jar=57464:C:\\Program Files\\JetBrains\\IntelliJ IDEA 2020.1.1\\bin, -Dfile.encoding=UTF-8]",
            "runTime": "0天0小时0分钟"
        },
        "sys": {
            "computerName": "DESKTOP-5DQGLBE",
            "computerIp": "192.168.123.63",
            "userDir": "D:\\ideaItems\\person-code\\my_ruoyi",
            "osName": "Windows 10",
            "osArch": "x86"
        },
        "sysFiles": [
            {
                "dirName": "C:\\",
                "sysTypeName": "NTFS",
                "typeName": "本地固定磁盘 (C:)",
                "total": "151.2 GB",
                "free": "66.5 GB",
                "used": "84.7 GB",
                "usage": 56.01
            },
            {
                "dirName": "D:\\",
                "sysTypeName": "NTFS",
                "typeName": "本地固定磁盘 (D:)",
                "total": "146.5 GB",
                "free": "105.0 GB",
                "used": "41.5 GB",
                "usage": 28.31
            },
            {
                "dirName": "E:\\",
                "sysTypeName": "NTFS",
                "typeName": "本地固定磁盘 (E:)",
                "total": "148.7 GB",
                "free": "133.5 GB",
                "used": "15.2 GB",
                "usage": 10.21
            },
            {
                "dirName": "F:\\",
                "sysTypeName": "NTFS",
                "typeName": "本地固定磁盘 (F:)",
                "total": "439.5 GB",
                "free": "392.9 GB",
                "used": "46.5 GB",
                "usage": 10.59
            },
            {
                "dirName": "G:\\",
                "sysTypeName": "NTFS",
                "typeName": "本地固定磁盘 (G:)",
                "total": "492.1 GB",
                "free": "450.8 GB",
                "used": "41.2 GB",
                "usage": 8.38
            }
        ]
    }
}

二、实现过程

1. 导入主要依赖

	  <!-- 获取系统信息 -->
      <dependency>
          <groupId>com.github.oshi</groupId>
          <artifactId>oshi-core</artifactId>
          <version>6.1.2</version>
      </dependency>

2. 接口信息

	@GetMapping("/getServer")
    public Res getServer() throws Exception {
        Server server = new Server();
        server.copyTo();
        return Res.success(server);
    }

3.实体类

1. 服务器相关信息

package com.ruoyi.framework.web.domain;

import java.net.UnknownHostException;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import com.ruoyi.common.utils.Arith;
import com.ruoyi.common.utils.ip.IpUtils;
import com.ruoyi.framework.web.domain.server.Cpu;
import com.ruoyi.framework.web.domain.server.Jvm;
import com.ruoyi.framework.web.domain.server.Mem;
import com.ruoyi.framework.web.domain.server.Sys;
import com.ruoyi.framework.web.domain.server.SysFile;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.CentralProcessor.TickType;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.software.os.FileSystem;
import oshi.software.os.OSFileStore;
import oshi.software.os.OperatingSystem;
import oshi.util.Util;

/**
 * 服务器相关信息
 * 
 * @author ruoyi
 */
public class Server
{
    private static final int OSHI_WAIT_SECOND = 1000;
    
    /**
     * CPU相关信息
     */
    private Cpu cpu = new Cpu();

    /**
     * 內存相关信息
     */
    private Mem mem = new Mem();

    /**
     * JVM相关信息
     */
    private Jvm jvm = new Jvm();

    /**
     * 服务器相关信息
     */
    private Sys sys = new Sys();

    /**
     * 磁盘相关信息
     */
    private List<SysFile> sysFiles = new LinkedList<SysFile>();

    public Cpu getCpu()
    {
        return cpu;
    }

    public void setCpu(Cpu cpu)
    {
        this.cpu = cpu;
    }

    public Mem getMem()
    {
        return mem;
    }

    public void setMem(Mem mem)
    {
        this.mem = mem;
    }

    public Jvm getJvm()
    {
        return jvm;
    }

    public void setJvm(Jvm jvm)
    {
        this.jvm = jvm;
    }

    public Sys getSys()
    {
        return sys;
    }

    public void setSys(Sys sys)
    {
        this.sys = sys;
    }

    public List<SysFile> getSysFiles()
    {
        return sysFiles;
    }

    public void setSysFiles(List<SysFile> sysFiles)
    {
        this.sysFiles = sysFiles;
    }

    public void copyTo() throws Exception
    {
        SystemInfo si = new SystemInfo();
        HardwareAbstractionLayer hal = si.getHardware();

        setCpuInfo(hal.getProcessor());

        setMemInfo(hal.getMemory());

        setSysInfo();

        setJvmInfo();

        setSysFiles(si.getOperatingSystem());
    }

    /**
     * 设置CPU信息
     */
    private void setCpuInfo(CentralProcessor processor)
    {
        // CPU信息
        long[] prevTicks = processor.getSystemCpuLoadTicks();
        Util.sleep(OSHI_WAIT_SECOND);
        long[] ticks = processor.getSystemCpuLoadTicks();
        long nice = ticks[TickType.NICE.getIndex()] - prevTicks[TickType.NICE.getIndex()];
        long irq = ticks[TickType.IRQ.getIndex()] - prevTicks[TickType.IRQ.getIndex()];
        long softirq = ticks[TickType.SOFTIRQ.getIndex()] - prevTicks[TickType.SOFTIRQ.getIndex()];
        long steal = ticks[TickType.STEAL.getIndex()] - prevTicks[TickType.STEAL.getIndex()];
        long cSys = ticks[TickType.SYSTEM.getIndex()] - prevTicks[TickType.SYSTEM.getIndex()];
        long user = ticks[TickType.USER.getIndex()] - prevTicks[TickType.USER.getIndex()];
        long iowait = ticks[TickType.IOWAIT.getIndex()] - prevTicks[TickType.IOWAIT.getIndex()];
        long idle = ticks[TickType.IDLE.getIndex()] - prevTicks[TickType.IDLE.getIndex()];
        long totalCpu = user + nice + cSys + idle + iowait + irq + softirq + steal;
        cpu.setCpuNum(processor.getLogicalProcessorCount());
        cpu.setTotal(totalCpu);
        cpu.setSys(cSys);
        cpu.setUsed(user);
        cpu.setWait(iowait);
        cpu.setFree(idle);
    }

    /**
     * 设置内存信息
     */
    private void setMemInfo(GlobalMemory memory)
    {
        mem.setTotal(memory.getTotal());
        mem.setUsed(memory.getTotal() - memory.getAvailable());
        mem.setFree(memory.getAvailable());
    }

    /**
     * 设置服务器信息
     */
    private void setSysInfo()
    {
        Properties props = System.getProperties();
        sys.setComputerName(IpUtils.getHostName());
        sys.setComputerIp(IpUtils.getHostIp());
        sys.setOsName(props.getProperty("os.name"));
        sys.setOsArch(props.getProperty("os.arch"));
        sys.setUserDir(props.getProperty("user.dir"));
    }

    /**
     * 设置Java虚拟机
     */
    private void setJvmInfo() throws UnknownHostException
    {
        Properties props = System.getProperties();
        jvm.setTotal(Runtime.getRuntime().totalMemory());
        jvm.setMax(Runtime.getRuntime().maxMemory());
        jvm.setFree(Runtime.getRuntime().freeMemory());
        jvm.setVersion(props.getProperty("java.version"));
        jvm.setHome(props.getProperty("java.home"));
    }

    /**
     * 设置磁盘信息
     */
    private void setSysFiles(OperatingSystem os)
    {
        FileSystem fileSystem = os.getFileSystem();
        List<OSFileStore> fsArray = fileSystem.getFileStores();
        for (OSFileStore fs : fsArray)
        {
            long free = fs.getUsableSpace();
            long total = fs.getTotalSpace();
            long used = total - free;
            SysFile sysFile = new SysFile();
            sysFile.setDirName(fs.getMount());
            sysFile.setSysTypeName(fs.getType());
            sysFile.setTypeName(fs.getName());
            sysFile.setTotal(convertFileSize(total));
            sysFile.setFree(convertFileSize(free));
            sysFile.setUsed(convertFileSize(used));
            sysFile.setUsage(Arith.mul(Arith.div(used, total, 4), 100));
            sysFiles.add(sysFile);
        }
    }

    /**
     * 字节转换
     * 
     * @param size 字节大小
     * @return 转换后值
     */
    public String convertFileSize(long size)
    {
        long kb = 1024;
        long mb = kb * 1024;
        long gb = mb * 1024;
        if (size >= gb)
        {
            return String.format("%.1f GB", (float) size / gb);
        }
        else if (size >= mb)
        {
            float f = (float) size / mb;
            return String.format(f > 100 ? "%.0f MB" : "%.1f MB", f);
        }
        else if (size >= kb)
        {
            float f = (float) size / kb;
            return String.format(f > 100 ? "%.0f KB" : "%.1f KB", f);
        }
        else
        {
            return String.format("%d B", size);
        }
    }
}

2. CPU相关设置

package com.ruoyi.framework.web.domain.server;

import com.ruoyi.common.utils.Arith;

/**
 * CPU相关信息
 * 
 * @author ruoyi
 */
public class Cpu
{
    /**
     * 核心数
     */
    private int cpuNum;

    /**
     * CPU总的使用率
     */
    private double total;

    /**
     * CPU系统使用率
     */
    private double sys;

    /**
     * CPU用户使用率
     */
    private double used;

    /**
     * CPU当前等待率
     */
    private double wait;

    /**
     * CPU当前空闲率
     */
    private double free;

    public int getCpuNum()
    {
        return cpuNum;
    }

    public void setCpuNum(int cpuNum)
    {
        this.cpuNum = cpuNum;
    }

    public double getTotal()
    {
        return Arith.round(Arith.mul(total, 100), 2);
    }

    public void setTotal(double total)
    {
        this.total = total;
    }

    public double getSys()
    {
        return Arith.round(Arith.mul(sys / total, 100), 2);
    }

    public void setSys(double sys)
    {
        this.sys = sys;
    }

    public double getUsed()
    {
        return Arith.round(Arith.mul(used / total, 100), 2);
    }

    public void setUsed(double used)
    {
        this.used = used;
    }

    public double getWait()
    {
        return Arith.round(Arith.mul(wait / total, 100), 2);
    }

    public void setWait(double wait)
    {
        this.wait = wait;
    }

    public double getFree()
    {
        return Arith.round(Arith.mul(free / total, 100), 2);
    }

    public void setFree(double free)
    {
        this.free = free;
    }
}

3. JVM信息

package com.study.myruoyi.entity.server;


import com.study.myruoyi.common.utils.Arith;
import com.study.myruoyi.common.utils.DateUtils;

import java.lang.management.ManagementFactory;

/**
 * JVM相关信息
 * 
 * @author ruoyi
 */
public class Jvm
{
    /**
     * 当前JVM占用的内存总数(M)
     */
    private double total;

    /**
     * JVM最大可用内存总数(M)
     */
    private double max;

    /**
     * JVM空闲内存(M)
     */
    private double free;

    /**
     * JDK版本
     */
    private String version;

    /**
     * JDK路径
     */
    private String home;

    public double getTotal()
    {
        return Arith.div(total, (1024 * 1024), 2);
    }

    public void setTotal(double total)
    {
        this.total = total;
    }

    public double getMax()
    {
        return Arith.div(max, (1024 * 1024), 2);
    }

    public void setMax(double max)
    {
        this.max = max;
    }

    public double getFree()
    {
        return Arith.div(free, (1024 * 1024), 2);
    }

    public void setFree(double free)
    {
        this.free = free;
    }

    public double getUsed()
    {
        return Arith.div(total - free, (1024 * 1024), 2);
    }

    public double getUsage()
    {
        return Arith.mul(Arith.div(total - free, total, 4), 100);
    }

    /**
     * 获取JDK名称
     */
    public String getName()
    {
        return ManagementFactory.getRuntimeMXBean().getVmName();
    }

    public String getVersion()
    {
        return version;
    }

    public void setVersion(String version)
    {
        this.version = version;
    }

    public String getHome()
    {
        return home;
    }

    public void setHome(String home)
    {
        this.home = home;
    }

    /**
     * JDK启动时间
     */
    public String getStartTime()
    {
        return DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, DateUtils.getServerStartDate());
    }

    /**
     * JDK运行时间
     */
    public String getRunTime()
    {
        return DateUtils.getDatePoor(DateUtils.getNowDate(), DateUtils.getServerStartDate());
    }

    /**
     * 运行参数
     */
    public String getInputArgs()
    {
        return ManagementFactory.getRuntimeMXBean().getInputArguments().toString();
    }
}

4. 内存信息

package com.ruoyi.framework.web.domain.server;

import com.ruoyi.common.utils.Arith;

/**
 * 內存相关信息
 * 
 * @author ruoyi
 */
public class Mem
{
    /**
     * 内存总量
     */
    private double total;

    /**
     * 已用内存
     */
    private double used;

    /**
     * 剩余内存
     */
    private double free;

    public double getTotal()
    {
        return Arith.div(total, (1024 * 1024 * 1024), 2);
    }

    public void setTotal(long total)
    {
        this.total = total;
    }

    public double getUsed()
    {
        return Arith.div(used, (1024 * 1024 * 1024), 2);
    }

    public void setUsed(long used)
    {
        this.used = used;
    }

    public double getFree()
    {
        return Arith.div(free, (1024 * 1024 * 1024), 2);
    }

    public void setFree(long free)
    {
        this.free = free;
    }

    public double getUsage()
    {
        return Arith.mul(Arith.div(used, total, 4), 100);
    }
}

5. 系统信息

package com.ruoyi.framework.web.domain.server;

/**
 * 系统相关信息
 * 
 * @author ruoyi
 */
public class Sys
{
    /**
     * 服务器名称
     */
    private String computerName;

    /**
     * 服务器Ip
     */
    private String computerIp;

    /**
     * 项目路径
     */
    private String userDir;

    /**
     * 操作系统
     */
    private String osName;

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

    public String getComputerName()
    {
        return computerName;
    }

    public void setComputerName(String computerName)
    {
        this.computerName = computerName;
    }

    public String getComputerIp()
    {
        return computerIp;
    }

    public void setComputerIp(String computerIp)
    {
        this.computerIp = computerIp;
    }

    public String getUserDir()
    {
        return userDir;
    }

    public void setUserDir(String userDir)
    {
        this.userDir = userDir;
    }

    public String getOsName()
    {
        return osName;
    }

    public void setOsName(String osName)
    {
        this.osName = osName;
    }

    public String getOsArch()
    {
        return osArch;
    }

    public void setOsArch(String osArch)
    {
        this.osArch = osArch;
    }
}

6. 系统文件信息

package com.ruoyi.framework.web.domain.server;

/**
 * 系统文件相关信息
 * 
 * @author ruoyi
 */
public class SysFile
{
    /**
     * 盘符路径
     */
    private String dirName;

    /**
     * 盘符类型
     */
    private String sysTypeName;

    /**
     * 文件类型
     */
    private String typeName;

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

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

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

    /**
     * 资源的使用率
     */
    private double usage;

    public String getDirName()
    {
        return dirName;
    }

    public void setDirName(String dirName)
    {
        this.dirName = dirName;
    }

    public String getSysTypeName()
    {
        return sysTypeName;
    }

    public void setSysTypeName(String sysTypeName)
    {
        this.sysTypeName = sysTypeName;
    }

    public String getTypeName()
    {
        return typeName;
    }

    public void setTypeName(String typeName)
    {
        this.typeName = typeName;
    }

    public String getTotal()
    {
        return total;
    }

    public void setTotal(String total)
    {
        this.total = total;
    }

    public String getFree()
    {
        return free;
    }

    public void setFree(String free)
    {
        this.free = free;
    }

    public String getUsed()
    {
        return used;
    }

    public void setUsed(String used)
    {
        this.used = used;
    }

    public double getUsage()
    {
        return usage;
    }

    public void setUsage(double usage)
    {
        this.usage = usage;
    }
}

7. 精确的浮点数运算工具

package com.study.myruoyi.common.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 精确的浮点数运算
 * 
 * @author ruoyi
 */
public class Arith
{

    /** 默认除法运算精度 */
    private static final int DEF_DIV_SCALE = 10;

    /** 这个类不能实例化 */
    private Arith()
    {
    }

    /**
     * 提供精确的加法运算。
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2)
    {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2)
    {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算。
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2)
    {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入。
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double div(double v1, double v2)
    {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     * @param v1 被除数
     * @param v2 除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale)
    {
        if (scale < 0)
        {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        if (b1.compareTo(BigDecimal.ZERO) == 0)
        {
            return BigDecimal.ZERO.doubleValue();
        }
        return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理。
     * @param v 需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale)
    {
        if (scale < 0)
        {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        BigDecimal one = BigDecimal.ONE;
        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
    }
}

参考：若依项目

XuDream
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
IDEA关闭但是项目还在运行_彻底解决Idea内存消耗严重和CPU资源占比严重的问题...
weixin_39709194的博客
11-20 2295
问题描述大多数人都知道使用idea时，发现idea内存消耗比较严重，尤其开启了tomcat后，过一段时间，idea的运行内存会被吃满，最近还发现编辑代码，提交代码，CPU占比可以直接飙升到100%，风扇呼呼作响，于是开始找各种解决方案。解决方案：1、卸载多余不常用的插件；2、设置某些idea配置，比如去掉某些动画、编译检查什么的；3、调整idea.vm.properties中的jvm大小...
gl-bench:GL具有CPUGPU负载的WebGL性能监视器
04-11
gl-bench WebGL性能监视器，显示GPU / CPU负载的百分比。 屏幕截图 范例/ e2e测试 利弊 优点 缺点 CPU / GPU百分比负载 仅随ES6类提供 酷主题和记录器 尺寸不是那么小 图表显示无效页面或明显的性能下降 一圈进行两次或更多次测量 支持具有120+ FPS的设备 网络工作者支持 打字稿支持 根据压力测试，它比Chrome中的Stats.js快2倍 这个怎么运作 对于GPU / CPU同步，我使用gl.getError（），至少对我而言，它比gl.readPixels（）更好。 代码是异步的，不会因为等待GPU回答而达到CPU极限而使渲染管线停顿，因此您可以使用此监视器在CPU上计算大量物理量。 如果要关闭GPU跟踪，只需单击一下就可以将其按下。 查看在线示例/ e2e测试以了解其工作原理。 版本1使用了EXT_disjoint_timer_query扩展
获取cpu相关信息
weixin_45145119的博客
04-16 256
function cpuInfo(cpuInfo, type) { var temp = '', cpuHardware; var fileReader = plus.android.importClass("java.io.FileReader"); var bufferedReader = plus.android.importClass("java.io.BufferedReader"); var FileReader = new fileReader(cpu
linux查看虚拟内存和cpu占用率
weixin_34162695的博客
10-09 337
top free cat/proc/meminfo cat/proc/cpuinfo [root@centerlisdbproc]#dmidecode|grep-A16"MemoryDevice"|more[objectObject] ==========================================================...
获取操作系统的CPU， 内存。。。
test的博客
08-20 398
使用时需要把对应的操作系统的脚本放到java安装包的bin目录下。 举个例子 package com.suosong.sigar; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.Map; import java.util.Properties; import org....
java读取服务器硬件信息（windowx+linux+Mac OS）
09-25
在Java编程中，读取服务器硬件信息是一项重要的任务，尤其对于跨平台的应用程序来说，能够兼容Windows、Linux和Mac OS等不同操作系统是必不可少的。本文将深入探讨如何使用Java来获取这些不同系统的硬件信息。 首先...
java获取电脑的硬件信息代码
07-23
本程序通过java准确获取电脑的硬件信息，中间用到第三方包，也一并放在本压缩文件中，里面有两个DLL动态链接库问价，要把这两个文件放在系统盘的SYSTEM32文件夹下面，合理配置第三方包就可以运行这个程序来获得电脑...
获取java虚拟机（JVM）和操作系统相关信息
最新发布
01-07
获取java虚拟机（JVM）和操作系统相关信息
使用sigar获取系统信息,内存，磁盘，jvm虚拟机等
01-27
本项目主要关注如何使用Sigar库在Java环境下获取系统信息，特别是内存、磁盘和JVM虚拟机的相关数据。 一、获取系统内存信息 在Java中使用Sigar库获取系统内存信息，主要涉及以下几个方面： 1. **总内存**：通过`...
与我一起学 JVM：Java 虚拟机内存组成概况
12-22
Java虚拟机（JVM）是Java程序的核心组成部分，它负责管理程序的运行时环境。本文将探讨JVM内存的组成，主要包括以下几个关键区域： 1. **程序计数器（Program Counter Register）**： - 程序计数器是一个很小的...
idea 显示内存占用，分配内存&实时内存
Clarence_Pang的博客
08-30 5221
4、打开开关，搞定！
获取当前电脑的CPU/内存/硬盘的总量、可用内存量、已使用情况
my_batis的博客
07-19 1079
Maven <dependency> <groupId>com.github.oshi</groupId> <artifactId>oshi-core</artifactId> <version>3.12.2</version> </dependency> <dependency> <groupId>net.java.d
Linux 命令查看vm有几个cpu，几个内存
m0_37845454的博客
02-07 2675
通过命令 cat /proc/cpuinfo 也可以查看cpu数量以及每个cpu的详细信息。free 以KB为单位的数据。free -h 以GB为单位的数据。free -m 以MB为单位的数据。
如何读取电脑html信息,JavaScript 获取客户端计算机硬件及系统信息
weixin_34362937的博客
07-01 793
JavaScript 获取客户端计算机硬件及系统信息//系统信息获取function getSysInfo(){var locator =new ActiveXObject ("WbemScripting.SWbemLocator");var service = locator.ConnectServer(".");//CPU信息var cpu =new Enumerator (service....
Java中获取CPU与内存利用率
农家小舍
02-23 2869
使用说明 代码示例 当我们需要获取当前机器的资源利用时，Java中如何获取呢？最方便的方式即使用com.sun.management.OperatingSystemMXBean来获取。 使用说明 虽然通过getProcessCpuLoad和getSystemCpuLoad可获取当前CPU的负载，但是当首次调用时，常常获取到的是不真实的值（甚至可能为负），且CPU负载常常是忽高忽低的，...
java获取系统CPU和内存使用率的三种方法
webxscan.com
01-02 2285
log.info("CPU总数 = {},CPU利用率 ={}",processor.getLogicalProcessorCount(),new DecimalFormat("#.##%").format(1.0-(idle * 1.0 / totalCpu)));log.info("CPU信息 = {}，CPU总数 = {},CPU基准速度 ={},CPU利用率 ={}",CPUinfo,totalCPUs,CPUSpeed,CPUPers);-- 代码库 -->-- 代码库 -->
java获取cpu的使用率_java如何获取系统CPU、内存占用
weixin_42361708的博客
02-12 4468
说明：获取的数据是操作系统整体的资源占用情况，不是当前 java进程占用的资源1. 获取系统CPU占用情况 ：import java.lang.management.ManagementFactory;import com.sun.management.OperatingSystemMXBean;private static OperatingSystemMXBean osmxb = (Opera...
SpringBoot项目使用OSHI获取系统状态信息报错
whtli的博客
04-13 1417
使用OSHI获取系统状态信息时，后端打印正常，返回至前端的过程中遇到了以下两个报错
Java全面获取系统信息：CPU、内存、硬盘与进程
"本文将介绍如何在Java中获取关于系统的各种信息，包括CPU、内存、硬盘和进程的状态。通过使用Java内置的类库，开发者可以轻松地获取到这些关键数据，以便监控和管理应用程序的性能。" 在Java中，获取系统信息主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XuDream

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值