java获取网络带宽_Linux Java 获取CPU使用率，内存使用率，磁盘IO，网络带宽使用率等等...

最新推荐文章于 2023-04-25 09:48:44 发布
最新推荐文章于 2023-04-25 09:48:44 发布
阅读量1.9k 收藏 6
点赞数 1
文章标签： java获取网络带宽
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33289964/article/details/114354594
版权 
 /**

* 获取带宽上传下载速度

* @return

*/

public String getNetWorkSpeed() {

boolean result = false;

String detailInfo = "";

DecimalFormat df = new DecimalFormat("0.00");

String dl = "";

String ul = "";

System.out.println("开始收集网络带宽使用率");

Process pro1,pro2;

Runtime r = Runtime.getRuntime();

try {

String command = "cat /proc/net/dev";

//第一次采集流量数据

long startTime = System.currentTimeMillis();

pro1 = r.exec(command);

BufferedReader in1 = new BufferedReader(new InputStreamReader(pro1.getInputStream()));

String line = null;

long inSize1 = 0, outSize1 = 0;

while((line=in1.readLine()) != null){

line = line.trim();

if(line.startsWith("eth0")){

System.out.println(line);

String[] temp = line.split("\\s+");

inSize1 = Long.parseLong(temp[1]); //Receive bytes,单位为Byte

outSize1 = Long.parseLong(temp[9]); //Transmit bytes,单位为Byte

break;

}

}

in1.close();

pro1.destroy();

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

System.out.println("NetUsage休眠时发生InterruptedException. " + e.getMessage());

System.out.println(sw.toString());

}

//第二次采集流量数据

long endTime = System.currentTimeMillis();

pro2 = r.exec(command);

BufferedReader in2 = new BufferedReader(new InputStreamReader(pro2.getInputStream()));

long inSize2 = 0 ,outSize2 = 0;

while((line=in2.readLine()) != null){

line = line.trim();

if(line.startsWith("eth0")){

System.out.println(line);

String[] temp = line.split("\\s+");

inSize2 = Long.parseLong(temp[1]);

outSize2 = Long.parseLong(temp[9]);

break;

}

}

//cal dl speed

float interval = (float)(endTime - startTime)/1000;

float currentDlSpeed = (float) ((float)(inSize2 - inSize1)/1024/interval);

float currentUlSpeed = (float) ((float)(outSize2 - outSize1)/1024/interval);

if((float)(currentDlSpeed/1024) >= 1){

currentDlSpeed = (float)(currentDlSpeed/1024);

dl = df.format(currentDlSpeed) + "Mb/s";

}else{

dl = df.format(currentDlSpeed) + "Kb/s";

}

if((float)(currentUlSpeed/1024) >= 1){

currentUlSpeed = (float)(currentUlSpeed/1024);

ul = df.format(currentUlSpeed) + "Mb/s";

}else{

ul = df.format(currentUlSpeed) + "Kb/s";

}

result = true;

in2.close();

pro2.destroy();

} catch (Exception e) {

e.printStackTrace();

detailInfo = e.getMessage();

}

return "{\"result\":\""+result+"\",\"detailInfo\":\""+detailInfo+"\",\"dl\":\""+dl+"\",\"ul\":\""+ul+"\"}";

}

/**

* 功能：内存使用率

* */

public float memoryUsage() {

Map map = new HashMap();

InputStreamReader inputs = null;

BufferedReader buffer = null;

try {

inputs = new InputStreamReader(new FileInputStream("/proc/meminfo"));

buffer = new BufferedReader(inputs);

String line = "";

while (true) {

line = buffer.readLine();

if (line == null)

break;

int beginIndex = 0;

int endIndex = line.indexOf(":");

if (endIndex != -1) {

String key = line.substring(beginIndex, endIndex);

beginIndex = endIndex + 1;

endIndex = line.length();

String memory = line.substring(beginIndex, endIndex);

String value = memory.replace("kB", "").trim();

map.put(key, value);

}

}

long memTotal = Long.parseLong(map.get("MemTotal").toString());

long memFree = Long.parseLong(map.get("MemFree").toString());

long memused = memTotal - memFree;

long buffers = Long.parseLong(map.get("Buffers").toString());

long cached = Long.parseLong(map.get("Cached").toString());

float usage = (float) (memused - buffers - cached) / memTotal;

return usage;

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

buffer.close();

inputs.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

return 0;

}

/**

* 获取分区的使用占用率

* @param path

* @return

*/

public float getPatitionUsage(String path){

File f = new File(path);

long total = f.getTotalSpace();

long free = f.getFreeSpace();

long used = total - free;

float usage = (float)used/total;

return usage;

}

/**

* 获取磁盘IO使用率

* @return

*/

public float getHdIOpPercent() {

System.out.println("开始收集磁盘IO使用率");

float ioUsage = 0.0f;

Process pro = null;

Runtime r = Runtime.getRuntime();

try {

String command = "iostat -d -x";

pro = r.exec(command);

BufferedReader in = new BufferedReader(new InputStreamReader(pro.getInputStream()));

String line = null;

int count = 0;

while((line=in.readLine()) != null){

if(++count >= 4){

// System.out.println(line);

String[] temp = line.split("\\s+");

if(temp.length > 1){

float util = Float.parseFloat(temp[temp.length-1]);

ioUsage = (ioUsage>util)?ioUsage:util;

}

}

}

if(ioUsage > 0){

System.out.println("本节点磁盘IO使用率为: " + ioUsage);

ioUsage /= 100;

}

in.close();

pro.destroy();

} catch (IOException e) {

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

System.out.println("IoUsage发生InstantiationException. " + e.getMessage());

System.out.println(sw.toString());

}

return ioUsage;

}

/**

* 获取带宽使使用率

* @return

*/

public float get() {

float TotalBandwidth = 1000;

System.out.println("开始收集网络带宽使用率");

float netUsage = 0.0f;

Process pro1,pro2;

Runtime r = Runtime.getRuntime();

try {

String command = "cat /proc/net/dev";

//第一次采集流量数据

long startTime = System.currentTimeMillis();

pro1 = r.exec(command);

BufferedReader in1 = new BufferedReader(new InputStreamReader(pro1.getInputStream()));

String line = null;

long inSize1 = 0, outSize1 = 0;

while((line=in1.readLine()) != null){

line = line.trim();

if(line.startsWith("eth0")){

System.out.println(line);

String[] temp = line.split("\\s+");

inSize1 = Long.parseLong(temp[1].substring(5)); //Receive bytes,单位为Byte

outSize1 = Long.parseLong(temp[9]); //Transmit bytes,单位为Byte

break;

}

}

in1.close();

pro1.destroy();

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

System.out.println("NetUsage休眠时发生InterruptedException. " + e.getMessage());

System.out.println(sw.toString());

}

//第二次采集流量数据

long endTime = System.currentTimeMillis();

pro2 = r.exec(command);

BufferedReader in2 = new BufferedReader(new InputStreamReader(pro2.getInputStream()));

long inSize2 = 0 ,outSize2 = 0;

while((line=in2.readLine()) != null){

line = line.trim();

if(line.startsWith("eth0")){

System.out.println(line);

String[] temp = line.split("\\s+");

inSize2 = Long.parseLong(temp[1].substring(5));

outSize2 = Long.parseLong(temp[9]);

break;

}

}

if(inSize1 != 0 && outSize1 !=0 && inSize2 != 0 && outSize2 !=0){

float interval = (float)(endTime - startTime)/1000;

//网口传输速度,单位为bps

float curRate = (float)(inSize2 - inSize1 + outSize2 - outSize1)*8/(1000000*interval);

netUsage = curRate/TotalBandwidth;

System.out.println("本节点网口速度为: " + curRate + "Mbps");

System.out.println("本节点网络带宽使用率为: " + netUsage);

}

in2.close();

pro2.destroy();

} catch (IOException e) {

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

System.out.println("NetUsage发生InstantiationException. " + e.getMessage());

System.out.println(sw.toString());

}

return netUsage;

}

/**

* 功能：可用磁盘

* */

public static int disk() {

try {

long total = FileSystemUtils.freeSpaceKb("/");

double disk = (double) total / 1024 / 1024;

return (int) disk;

} catch (IOException e) {

e.printStackTrace();

}

return 0;

}

/**

* 功能：获取Linux系统cpu使用率

* */

public static String cpuUsage() {

try {

Map, ?> map1 = SysStatusInfo.cpuinfo();

Thread.sleep(1 * 1000);

Map, ?> map2 = SysStatusInfo.cpuinfo();

long user1 = Long.parseLong(map1.get("user").toString());

long nice1 = Long.parseLong(map1.get("nice").toString());

long system1 = Long.parseLong(map1.get("system").toString());

long idle1 = Long.parseLong(map1.get("idle").toString());

long user2 = Long.parseLong(map2.get("user").toString());

long nice2 = Long.parseLong(map2.get("nice").toString());

long system2 = Long.parseLong(map2.get("system").toString());

long idle2 = Long.parseLong(map2.get("idle").toString());

long total1 = user1 + system1 + nice1;

long total2 = user2 + system2 + nice2;

float total = total2 - total1;

long totalIdle1 = user1 + nice1 + system1 + idle1;

long totalIdle2 = user2 + nice2 + system2 + idle2;

float totalidle = totalIdle2 - totalIdle1;

DecimalFormat df = new DecimalFormat(".0");

float cpusage = (float)(total / totalidle) * 100;

String value = df.format(cpusage);

return value;

} catch (InterruptedException e) {

e.printStackTrace();

}

return "0";

}

/**

* 功能：CPU使用信息

* */

public static Map, ?> cpuinfo() {

InputStreamReader inputs = null;

BufferedReader buffer = null;

Map map = new HashMap();

try {

inputs = new InputStreamReader(new FileInputStream("/proc/stat"));

buffer = new BufferedReader(inputs);

String line = "";

while (true) {

line = buffer.readLine();

if (line == null) {

break;

}

if (line.startsWith("cpu")) {

StringTokenizer tokenizer = new StringTokenizer(line);

List temp = new ArrayList();

while (tokenizer.hasMoreElements()) {

String value = tokenizer.nextToken();

temp.add(value);

}

map.put("user", temp.get(1));

map.put("nice", temp.get(2));

map.put("system", temp.get(3));

map.put("idle", temp.get(4));

map.put("iowait", temp.get(5));

map.put("irq", temp.get(6));

map.put("softirq", temp.get(7));

map.put("stealstolen", temp.get(8));

break;

}

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

buffer.close();

inputs.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

return map;

}

int kb = 1024;

OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory

.getOperatingSystemMXBean();

// 操作系统

String osName = System.getProperty("os.name");

// 总的物理内存

long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;

// 剩余的物理内存

long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;

// 已使用的物理内存

long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb.getFreePhysicalMemorySize()) / kb;

/**

* 获取CPU使用率

* @return

*/

public float getCpuUsage() {

System.out.println("开始收集cpu使用率");

float cpuUsage = 0;

Process pro1,pro2;

Runtime r = Runtime.getRuntime();

try {

String command = "cat /proc/stat";

//第一次采集CPU时间

long startTime = System.currentTimeMillis();

pro1 = r.exec(command);

BufferedReader in1 = new BufferedReader(new InputStreamReader(pro1.getInputStream()));

String line = null;

long idleCpuTime1 = 0, totalCpuTime1 = 0; //分别为系统启动后空闲的CPU时间和总的CPU时间

while((line=in1.readLine()) != null){

if(line.startsWith("cpu")){

line = line.trim();

System.out.println(line);

String[] temp = line.split("\\s+");

idleCpuTime1 = Long.parseLong(temp[4]);

for(String s : temp){

if(!s.equals("cpu")){

totalCpuTime1 += Long.parseLong(s);

}

}

System.out.println("IdleCpuTime: " + idleCpuTime1 + ", " + "TotalCpuTime" + totalCpuTime1);

break;

}

}

in1.close();

pro1.destroy();

try {

Thread.sleep(100);

} catch (InterruptedException e) {

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

System.out.println("CpuUsage休眠时发生InterruptedException. " + e.getMessage());

System.out.println(sw.toString());

}

//第二次采集CPU时间

long endTime = System.currentTimeMillis();

pro2 = r.exec(command);

BufferedReader in2 = new BufferedReader(new InputStreamReader(pro2.getInputStream()));

long idleCpuTime2 = 0, totalCpuTime2 = 0; //分别为系统启动后空闲的CPU时间和总的CPU时间

while((line=in2.readLine()) != null){

if(line.startsWith("cpu")){

line = line.trim();

System.out.println(line);

String[] temp = line.split("\\s+");

idleCpuTime2 = Long.parseLong(temp[4]);

for(String s : temp){

if(!s.equals("cpu")){

totalCpuTime2 += Long.parseLong(s);

}

}

System.out.println("IdleCpuTime: " + idleCpuTime2 + ", " + "TotalCpuTime" + totalCpuTime2);

break;

}

}

if(idleCpuTime1 != 0 && totalCpuTime1 !=0 && idleCpuTime2 != 0 && totalCpuTime2 !=0){

cpuUsage = 1 - (float)(idleCpuTime2 - idleCpuTime1)/(float)(totalCpuTime2 - totalCpuTime1);

System.out.println("本节点CPU使用率为: " + cpuUsage);

}

in2.close();

pro2.destroy();

} catch (IOException e) {

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

System.out.println("CpuUsage发生InstantiationException. " + e.getMessage());

System.out.println(sw.toString());

}

return cpuUsage;

}

获取MAC

Windows

/**

* 获取MAC地址

*

* @return

*/

public String getMac() {

NetworkInterface byInetAddress;

try {

InetAddress localHost = InetAddress.getLocalHost();

byInetAddress = NetworkInterface.getByInetAddress(localHost);

byte[] hardwareAddress = byInetAddress.getHardwareAddress();

return getMacFromBytes(hardwareAddress);

} catch (SocketException e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println(getLocalTime()+"获取mac地址失败：" + e.getMessage());

} catch (UnknownHostException e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println(getLocalTime()+"获取mac地址失败：" + e.getMessage());

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println(getLocalTime()+"获取mac地址失败：" + e.getMessage());

}

return null;

}

public String getMacFromBytes(byte[] bytes) {

StringBuffer mac = new StringBuffer();

byte currentByte;

boolean first = false;

for (byte b : bytes) {

if (first) {

mac.append("-");

}

currentByte = (byte) ((b & 240) >> 4);

mac.append(Integer.toHexString(currentByte));

currentByte = (byte) (b & 15);

mac.append(Integer.toHexString(currentByte));

first = true;

}

return mac.toString().toLowerCase();

}

Linux

/**

* 获取MAC

*

* @return

*/

public String getMac() {

String result = "";

try {

Enumeration networkInterfaces = NetworkInterface

.getNetworkInterfaces();

while (networkInterfaces.hasMoreElements()) {

NetworkInterface network = networkInterfaces.nextElement();

System.out.println("network : " + network);

byte[] mac = network.getHardwareAddress();

if (mac == null) {

System.out.println("null mac");

} else {

System.out.print("MAC address : ");

StringBuilder sb = new StringBuilder();

for (int i = 0; i < mac.length; i++) {

sb.append(String.format("%02X%s", mac[i],

(i < mac.length - 1) ? ":" : ""));

}

result = sb.toString();

System.out.println(sb.toString());

break;

}

}

} catch (SocketException e) {

e.printStackTrace();

}

return result;

}

苘郁蓁
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用shell脚本采集系统cpu、内存、磁盘、网络等信息
09-15
主要介绍了使用shell脚本采集系统cpu、内存、磁盘、网络等信息,需要的朋友可以参考下
使用iperf工具，用java的swing，编写网络带宽监测小工具
zifengye520的专栏
05-29 1664
接到一个需求，要写个简单的工具，测试本机的CPU、内存等信息，以及监测当前主机与连接的服务器之间的网速信息 获取CPU和内存的方法，此处省略，重点是监测网速这一块 先看下工具的目录结构： jperf是需要用到测试网络带宽的工具包，jar包是需要运行的项目，run.bat是项目的启动文件，serverInfo文件是用来配置服务器IP和端口的 再看下效果图： 一、获取网络信息，需要利用...
java 获取网络带宽_Java开发网 - 一个测网络延迟和带宽的程序,发10M的数据有问题...
weixin_29473667的博客
03-05 1084
我的想法是客户端发10M的string给服务器,服务器把收到的数据返回给客户端,客户端记下发送的时刻和收完数据的时刻,两者相减再除2就是传输用的时间.发1M没有问题,现在要发10M,就循环10次,结果服务器和客户端都陷入了循环,不知问题出在哪,请大家指点,谢谢!客户端程序如下import java.io.*;import javax.net.ssl.SSLSocket;import javax.n...
在线网络速度测试JAVA程序（一）：思路和控制台主程序【转】
weixin_30709809的博客
01-18 398
来源：http://hancool.blog.51cto.com/1836252/1352228 事情的缘由 因上级公司的信息化主管部门经常被投诉说是各种业务应用系统反映系统使用慢的问题，而都把问题归结于网速不给力。而业务系统一部份是总公司一级部署的，其它很多都是各个业务部门各自为政建设的，不知道从哪里找来的各种小公司，搞的五法八门的技术路线，没得统一标准、技术平台，所以水平就参差不齐。人少的...
Android 学习笔记之二 Netspeed
底层码农
04-21 859
今天看项目源码发现获取Android网速有问题，就此改了一下，做个笔记留给自己看。 下面代码放在工具类里： [java] view plain copy   public static long getNetworkSpeed(Context context) {       ProcessBuilder cmd;       long 
java测试网速，获取本机信息
weixin_44394502的博客
04-25 848
对当前计算机的操作
springcloud dashboard_快速搭建 SpringCloud 微服务开发环境的脚手架
weixin_39752352的博客
11-21 397
本文作者：HelloGitHub-秦人本文适合有 SpringBoot 和 SpringCloud 基础知识的人群，跟着本文可使用和快速搭建 SpringCloud 项目。HelloGitHub 推出的《讲解开源项目》系列，今天给大家带来一款基于 SpringCloud2.1 的微服务开发脚手开源项目——SpringCloud 项目源码地址：https://github.com/zhoutaoo/...
java 获取网络带宽_带宽计算方法
weixin_39978696的博客
02-25 2228
碰到很多朋友总问下载速度怎么怎么的。现在给大家做个介绍比特(bit)：内存中最小的单位，二进制数序列中的一个0或一个1就是一比比特，②1 Byte＝8bit(位)。③1KB＝1024Byte(字节)④1 MB＝1024KB。⑤1GB＝1024MB。⑥TB、Tera byte：1TB＝1024GB。1比特 = 一个二进制位，只有0和1两种状态1字节 = 8 比特1k字节 = 1024字节(字节英文为...
Linux下java获取CPU、内存、磁盘IO、网络带宽使用率
热门推荐
blue_jjw的专栏
03-30 9万+
一、CPU 使用proc文件系统，"proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。用户和应用程序可以通过proc得到系统的信息，并可以改变内核的某些参数。" 从/proc文件系统获取cpu使用情况：    cat /proc/stat 在Linux的内核中，有一个全 局变量：Jiffies。 Jiffie
uriel:NodeJS statsd代理来推送内存，cpu，网络，交换，diskio和磁盘使用情况
05-03
一个简单的服务，将系统信息（例如系统使用率，内存，cpu，网络，交换，磁盘和磁盘使用率）推送到任何兼容的statsd服务（例如StatsD，Telegraf，DogStatsD等） 注意： 2.0.0版包含一些重大更改，这些更改涉及将...
用java做的测试服务器带宽项目（原创）
10-02
用java做的测试服务器带宽项目，可以保持连接不断测试局域网的带宽
Memory_CPU_IO_used.zip
03-16
监控liunx服务器cpu、磁盘、内存 使用率脚本
nodejs的io获取，包括cpu，disk等
06-04
获取内存，cpu使用率，磁盘，网络，网络连接的nodejs程序
Windows利用Pdh读取机器的磁盘，网络，CPU等信息
03-28
Windows上利用Pdh读取电脑的磁盘使用情况，网络下载上传流量，磁盘读写速率，CPU使用率等。Win32，C++，MFC
infrared-remote-candroid studiodemo
05-05
android studio下载
【新质生产力】新质生产力赋能智能制造数字化解决方案.pptx
05-05
【新质生产力】新质生产力赋能智能制造数字化解决方案.pptx
基于matlab实现的用于应用布格重力异常数据反演地下异常密度体.rar
05-05
基于matlab实现的用于应用布格重力异常数据反演地下异常密度体.rar
node-v8.10.0-linux-x64.tar.xz
最新发布
05-05
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
java获取系统CPU和内存和磁盘使用率
04-12
您可以使用Java中的ManagementFactory类来获取系统的CPU和内存使用率。以下是获取系统CPU使用率的示例代码： ``` import java.lang.management.ManagementFactory; import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值