JAVA内存读写速度极限_java获取JVM的CPU占用率、内存占用率、线程数及服务器的网口吞吐率、磁盘读写速率...

最新推荐文章于 2022-07-04 20:52:39 发布

weixin_39716921

最新推荐文章于 2022-07-04 20:52:39 发布

阅读量387

点赞数

文章标签： JAVA内存读写速度极限

本文链接：https://blog.csdn.net/weixin_39716921/article/details/114502750

版权

怎么说呢，本人菜鸟一枚，费了几天时间，终于做了一个用java获取JVM的CPU占用率、内存占用率、线程数及服务器的网口吞吐率、磁盘读写速率的实现。其中windows环境下获取jvm 的cpu占用率这里是参考网上别人

的东西(在此感谢提供参考的网友)，其他的都是基于自己的想法做出来的。该工具类亲测在win7 64位系统和CentOS6系统没有问题，其他的暂时没有测过，欢迎高手指教，勿喷勿喷，感谢手下留情~

运行环境：jdk 1.8 + tomcat 7 + Spring 4.3

tomcat 容器启动及进入init()进行JVM PID的获取及执行任务

可能会碰到的问题：无法引入com.sun.management.OperatingSystemMXBean

解决方案：Eclipse默认把这些受访问限制的API设成了ERROR。只要把Windows-Preferences-Java-Complicer-Errors/Warnings里面的Deprecated and restricted API中的Forbidden references(access rules),选为Warning就可以编译通过。

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.LineNumberReader;

import java.lang.management.ManagementFactory;

import java.lang.management.RuntimeMXBean;

import java.util.Formatter;

import java.util.StringTokenizer;

import java.util.Timer;

import java.util.TimerTask;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import com.alibaba.fastjson.serializer.SerializerFeature;

import com.nufront.euht.model.SysPerformInfo;

import com.nufront.euht.service.api.sys.SysPerformInfoServiceI;

import com.nufront.euht.util.UuidUtil;

import com.sun.management.OperatingSystemMXBean;

/**

* 网管信息信息信息采集类

* @author liming.cen

* @date 2017-4-11

@Service

public class SysInfoAcquirerService {

private static final int CPUTIME = 5000;

/**

* 网管进程信息采集周期(注意：PERIOD_TIME 一定要大于 SLEEP_TIME )

private static final int PERIOD_TIME = 1000 * 60 * 15;

/**

* 此类中Thread.sleep()里的线程睡眠时间

private static final int SLEEP_TIME = 1000 * 60 * 9;

private static final int PERCENT = 100;

private static final int FAULTLENGTH = 10;

private String isWindowsOrLinux = isWindowsOrLinux();

private String pid = "";

private Timer sysInfoGetTimer = new Timer("sysInfoGet");

@Autowired

private SysPerformInfoServiceI sysPerformInfoService;

public Logger log = Logger.getLogger(SysInfoAcquirerService.class);

/**

* 初始化bean的时候就立即获取JVM进程的PID及执行任务

* @return

@PostConstruct

public void init() {

if (isWindowsOrLinux.equals("windows")) { // 判断操作系统类型是否为：windows

getJvmPIDOnWindows();

} else {

getJvmPIDOnLinux();

}

sysInfoGetTimer.schedule(new SysInfoAcquirerTimerTask(), 10 * 1000, PERIOD_TIME);

}

/**

* 判断是服务器的系统类型是Windows 还是 Linux

* @return

public String isWindowsOrLinux() {

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

String sysName = "";

if (osName.toLowerCase().startsWith("windows")) {

sysName = "windows";

} else if (osName.toLowerCase().startsWith("linux")) {

sysName = "linux";

}

return sysName;

}

/**

* 获取JVM 的CPU占用率(%)

* @return

public String getCPURate() {

String cpuRate = "";

if (isWindowsOrLinux.equals("windows")) { // 判断操作系统类型是否为：windows

cpuRate = getCPURateForWindows();

} else {

cpuRate = getCPURateForLinux();

}

return cpuRate;

}

/**

* windows环境下获取JVM的PID

public void getJvmPIDOnWindows() {

RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();

pid = runtime.getName().split("@")[0];

log.info("PID of JVM:" + pid);

}

/**

* linux环境下获取JVM的PID

public void getJvmPIDOnLinux() {

String command = "pidof java";

BufferedReader in = null;

Process pro = null;

try {

pro = Runtime.getRuntime().exec(new String[] { "sh", "-c", command });

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

StringTokenizer ts = new StringTokenizer(in.readLine());

pid = ts.nextToken();

log.info("PID of JVM:" + pid);

} catch (IOException e) {

e.printStackTrace();

}

/**

* 获取JVM的内存占用率(%)

* @return

public String getMemoryRate() {

String memRate = "";

if (isWindowsOrLinux.equals("windows")) { // 判断操作系统类型是否为：windows

memRate = getMemoryRateForWindows();// 查询windows系统的cpu占用率

} else {

memRate = getMemoryRateForLinux();// 查询linux系统的cpu占用率

}

return memRate;

}

/**

* 获取JVM 线程数

* @return

public int getThreadCount() {

int threadCount = 0;

if (isWindowsOrLinux.equals("windows")) { // 判断操作系统类型是否为：windows

threadCount = getThreadCountForWindows();// 查询windows系统的线程数

} else {

threadCount = getThreadCountForLinux();// 查询linux系统的线程数

}

return threadCount;

}

/**

* 获取磁盘读写速率(MB/s)

* @return

// public String getDiskAccess() { // TODO:待完成

// String diskAccess = "";

// if (isWindowsOrLinux.equals("windows")) { // 判断操作系统类型是否为：windows

// // diskAccess = getDiskAccessForWindows(); // 查询windows系统的磁盘读写速率

// } else {

// diskAccess = getDiskAccessForLinux(); // 查询linux系统的磁盘读写速率

// }

// return diskAccess;

// }

/**

* 获取网口吞吐量(MB/s)

* @return

public String getNetworkThroughput() {

String throughput = "";

if (isWindowsOrLinux.equals("windows")) { // 判断操作系统类型是否为：windows

throughput = getNetworkThroughputForWindows(); // 查询windows系统的磁盘读写速率

} else {

throughput = getNetworkThroughputForLinux(); // 查询linux系统的磁盘读写速率

}

return throughput;

}

/**

* 获取Windows环境下网口的上下行速率

* @return

public String getNetworkThroughputForWindows() {

Process pro1 = null;

Process pro2 = null;

Runtime r = Runtime.getRuntime();

BufferedReader input = null;

String rxPercent = "";

String txPercent = "";

JSONObject jsonObject = new JSONObject();

try {

String command = "netstat -e";

pro1 = r.exec(command);

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

String result1[] = readInLine(input, "windows");

Thread.sleep(SLEEP_TIME);

pro2 = r.exec(command);

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

String result2[] = readInLine(input, "windows");

rxPercent = formatNumber((Long.parseLong(result2[0]) - Long.parseLong(result1[0]))

/ (float) (1024 * 1024 * (SLEEP_TIME / 1000))); // 上行速率(MB/s)

txPercent = formatNumber((Long.parseLong(result2[1]) - Long.parseLong(result1[1]))

/ (float) (1024 * 1024 * (SLEEP_TIME / 1000))); // 下行速率(MB/s)

input.close();

pro1.destroy();

pro2.destroy();

} catch (Exception e) {

log.error(e.getMessage());

}

jsonObject.put("rxPercent", rxPercent); // 下行速率

jsonObject.put("txPercent", txPercent); // 上行速率

return JSON.toJSONStringWithDateFormat(jsonObject, "yyyy-MM-dd HH:mm:ss", SerializerFeature.WriteMapNullValue);

}

/**

* 获取Linux环境下网口的上下行速率

* @return

public String getNetworkThroughputForLinux() {

Process pro1 = null;

Process pro2 = null;

Runtime r = Runtime.getRuntime();

BufferedReader input = null;

String rxPercent = "";

String txPercent = "";

JSONObject jsonObject = new JSONObject();

try {

String command = "watch ifconfig";

pro1 = r.exec(command);

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

String result1[] = readInLine(input, "linux");

Thread.sleep(SLEEP_TIME);

pro2 = r.exec(command);

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

String result2[] = readInLine(input, "linux");

rxPercent = formatNumber((Long.parseLong(result2[0]) - Long.parseLong(result1[0]))

/ (float) (1024 * 1024 * (SLEEP_TIME / 1000))); // 下行速率(MB/s)

txPercent = formatNumber((Long.parseLong(result2[1]) - Long.parseLong(result1[1]))

/ (float) (1024 * 1024 * (SLEEP_TIME / 1000))); // 上行速率(MB/s)

input.close();

pro1.destroy();

pro2.destroy();

} catch (Exception e) {

log.error(e.getMessage());

}

jsonObject.put("rxPercent", rxPercent); // 下行速率

jsonObject.put("txPercent", txPercent); // 上行速率

return JSON.toJSONStringWithDateFormat(jsonObject, "yyyy-MM-dd HH:mm:ss", SerializerFeature.WriteMapNullValue);

}

/**

* 获取windows环境下JVM的cpu占用率

* @return

public String getCPURateForWindows() {

try {

String procCmd = System.getenv("windir") + "\\system32\\wbem\\wmic.exe process "

+ " get Caption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";

// 取进程信息

long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));

Thread.sleep(CPUTIME);

long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));

if (c0 != null && c1 != null) {

long idletime = c1[0] - c0[0];

long busytime = c1[1] - c0[1];

long cpuRate = PERCENT * (busytime) / (busytime + idletime);

if (cpuRate > 100) {

cpuRate = 100;

} else if (cpuRate < 0) {

cpuRate = 0;

}

return String.valueOf(PERCENT * (busytime) / (busytime + idletime));

} else {

return "0.0";

}

} catch (Exception ex) {

ex.printStackTrace();

return "0.0";

}

/**

* 获取linux环境下JVM的cpu占用率

* @return

public String getCPURateForLinux() {

InputStream is = null;

InputStreamReader isr = null;

BufferedReader brStat = null;

StringTokenizer tokenStat = null;

String user = "";

String linuxVersion = System.getProperty("os.version");

try {

System.out.println("Linux版本: " + linuxVersion);

Process process = Runtime.getRuntime().exec(new String[] { "sh", "-c", "top -b -p " + pid });

try {

// top命令默认3秒动态更新结果信息，让线程睡眠5秒以便获取最新结果

Thread.sleep(CPUTIME);

is = process.getInputStream();

} catch (InterruptedException e) {

e.printStackTrace();

}

isr = new InputStreamReader(is);

brStat = new BufferedReader(isr);

if (linuxVersion.equals("2.4")) {

brStat.readLine();

tokenStat = new StringTokenizer(brStat.readLine());

tokenStat.nextToken();

user = tokenStat.nextToken();

tokenStat.nextToken();

String system = tokenStat.nextToken();

tokenStat.nextToken();

String nice = tokenStat.nextToken();

System.out.println(user + " , " + system + " , " + nice);

user = user.substring(0, user.indexOf("%"));

system = system.substring(0, system.indexOf("%"));

nice = nice.substring(0, nice.indexOf("%"));

float userUsage = new Float(user).floatValue();

float systemUsage = new Float(system).floatValue();

float niceUsage = new Float(nice).floatValue();

return String.valueOf((userUsage + systemUsage + niceUsage) / 100);

} else {

brStat.readLine();

tokenStat = new StringTokenizer(brStat.readLine());

tokenStat.nextToken();

String userUsage = tokenStat.nextToken(); // 用户空间占用CPU百分比

user = userUsage.substring(0, userUsage.indexOf("%"));

process.destroy();

}

} catch (IOException ioe) {

System.out.println(ioe.getMessage());

freeResource(is, isr, brStat);

return "100";

} finally {

freeResource(is, isr, brStat);

}

return user; // jvm cpu占用率

}

/**

* 获取Linux环境下JVM的内存占用率

* @return

public String getMemoryRateForLinux() {

Process pro = null;

Runtime r = Runtime.getRuntime();

String remCount = "";

try {

String command = "top -b -n 1 -H -p" + pid;

pro = r.exec(command);

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

in.readLine();

StringTokenizer ts = new StringTokenizer(in.readLine());

int i = 1;

while (ts.hasMoreTokens()) {

i++;

ts.nextToken();

if (i == 10) {

remCount = ts.nextToken();

}

in.close();

pro.destroy();

} catch (Exception e) {

log.error(e.getMessage());

}

return remCount;

}

/**

* 获取windows环境下jvm的内存占用率

* @return

public String getMemoryRateForWindows() {

String command = "TASKLIST /NH /FO CSV /FI \"PID EQ " + pid + " \"";

String remCount = ""; // jvm物理内存占用量

BufferedReader in = null;

String result = "";

try {

Process pro = Runtime.getRuntime().exec(command);

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

StringTokenizer ts = new StringTokenizer(in.readLine(), "\"");

int i = 1;

while (ts.hasMoreTokens()) {

i++;

ts.nextToken();

if (i == 9) {

remCount = ts.nextToken().replace(",", "").replace("K", "").trim();

}

long physicalJvmMem = Long.parseLong(remCount) / 1024; // jvm物理内存占用量(MB)

OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();

long physicalTotal = osmxb.getTotalPhysicalMemorySize() / (1024 * 1024); // 获取服务器总物理内存(MB)

result = formatNumber(physicalJvmMem / (float) physicalTotal);

if (Float.parseFloat(result) > 1) { // 占用率最多只能是100%

result = "1";

} else if (Float.parseFloat(result) < 0) {

result = "0";

}

in.close();

pro.destroy();

} catch (Exception e) {

log.error("getThreadCountForWindows()报异常：" + e);

}

return String.valueOf((Float.parseFloat(result) * 100));

}

/**

* 获取linux磁盘读写速率

* @return

// public String getDiskAccessForLinux() {

// Process pro = null;

// Runtime r = Runtime.getRuntime();

// String command = "time dd if=/dev/zero of=/temp.log bs=1024k count=1000";

// // 读取和写入1G数据

// BufferedReader in = null;

// float result = 0.0f;

// try {

// pro = r.exec(new String[] { "sh", "-c", command });

// // pro.getInputStream()取不到结果内容，反而是getErrorStream()可以取到值

// in = new BufferedReader(new InputStreamReader(pro.getErrorStream()));

// in.readLine();

// if (getLocale().indexOf("zh") != -1) { // 中文语言环境

// StringTokenizer ts = new StringTokenizer(in.readLine(), "，");

// ts.nextToken();

// result = Float.parseFloat(ts.nextToken().split(" ")[0]);

// System.out.println("中文环境");

// } else { // 英文语言环境

// StringTokenizer ts = new StringTokenizer(in.readLine());

// ts.nextToken();

// result = Float.parseFloat(ts.nextToken().split(" ")[0]);

// System.out.println("英文环境");

// }

// r.exec("rm -f /temp.log"); // 将生成的文件删掉

// in.close();

// pro.destroy();

// } catch (IOException e) {

// System.out.println(e.getMessage());

// }

// return String.valueOf(result);

// }

/**

* 获取Linux服务器的语言环境

* @return

public String getLocale() {

Process pro = null;

Runtime r = Runtime.getRuntime();

String command = "locale";

BufferedReader in = null;

StringTokenizer ts = null;

try {

pro = r.exec(command);

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

ts = new StringTokenizer(in.readLine());

in.close();

pro.destroy();

} catch (IOException e) {

System.out.println(e.getMessage());

}

return ts.nextToken();

}

/**

* 获取Linux环境下JVM的线程数

* @return

public int getThreadCountForLinux() {

Process pro = null;

Runtime r = Runtime.getRuntime();

String command = "top -b -n 1 -H -p " + pid;

BufferedReader in = null;

int result = 0;

try {

pro = r.exec(new String[] { "sh", "-c", command });

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

in.readLine();

StringTokenizer ts = new StringTokenizer(in.readLine());

ts.nextToken();

result = Integer.parseInt(ts.nextToken());

in.close();

pro.destroy();

} catch (IOException e) {

e.printStackTrace();

}

return result;

}

/**

* 获取Windows环境下JVM的线程数

* @return

public int getThreadCountForWindows() {

String command = "wmic process " + pid + " list brief";

int count = 0;

BufferedReader in = null;

try {

Process pro = Runtime.getRuntime().exec(command);

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

// testGetInput(in);

in.readLine();

StringTokenizer ts = new StringTokenizer(in.readLine());

int i = 1;

while (ts.hasMoreTokens()) {

i++;

ts.nextToken();

if (i == 5) {

count = Integer.parseInt(ts.nextToken());

}

in.close();

pro.destroy();

} catch (Exception e) {

log.error("getThreadCountForWindows()报异常：" + e);

}

return count;

}

private void freeResource(InputStream is, InputStreamReader isr, BufferedReader br) {

try {

if (is != null)

is.close();

if (isr != null)

isr.close();

if (br != null)

br.close();

} catch (IOException ioe) {

System.out.println(ioe.getMessage());

}

/**

* 读取CPU信息

* @param proc

* @return

private long[] readCpu(final Process proc) {

long[] retn = new long[2];

try {

proc.getOutputStream().close();

InputStreamReader ir = new InputStreamReader(proc.getInputStream());

LineNumberReader input = new LineNumberReader(ir);

String line = input.readLine();

if (line == null || line.length() < FAULTLENGTH) {

return null;

}

int capidx = line.indexOf("Caption");

int cmdidx = line.indexOf("CommandLine");

int rocidx = line.indexOf("ReadOperationCount");

int umtidx = line.indexOf("UserModeTime");

int kmtidx = line.indexOf("KernelModeTime");

int wocidx = line.indexOf("WriteOperationCount");

// Caption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount

long idletime = 0;

long kneltime = 0;

long usertime = 0;

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

if (line.length() < wocidx) {

continue;

}

// 字段出现顺序：Caption,CommandLine,KernelModeTime,ReadOperationCount,

// ThreadCount,UserModeTime,WriteOperation

String caption = this.substring(line, capidx, cmdidx - 1).trim();

String cmd = this.substring(line, cmdidx, kmtidx - 1).trim();

if (cmd.indexOf("javaw.exe") >= 0) {

continue;

}

// log.info("line="+line);

if (caption.equals("System Idle Process") || caption.equals("System")) {

idletime += Long.valueOf(this.substring(line, kmtidx, rocidx - 1).trim()).longValue();

idletime += Long.valueOf(this.substring(line, umtidx, wocidx - 1).trim()).longValue();

continue;

}

kneltime += Long.valueOf(this.substring(line, kmtidx, rocidx - 1).trim()).longValue();

usertime += Long.valueOf(this.substring(line, umtidx, wocidx - 1).trim()).longValue();

}

retn[0] = idletime;

retn[1] = kneltime + usertime;

return retn;

} catch (Exception ex) {

ex.printStackTrace();

} finally {

try {

proc.getInputStream().close();

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* 获取网口上下行速率

* @param input

* @return

public String[] readInLine(BufferedReader input, String osType) {

String rxResult = "";

String txResult = "";

StringTokenizer tokenStat = null;

try {

if (osType.equals("linux")) { // 获取linux环境下的网口上下行速率

String result[] = input.readLine().split(" ");

int j = 0, k = 0;

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

if (result[i].indexOf("RX") != -1) {

j++;

if (j == 2) {

rxResult = result[i + 1].split(":")[1];

}

if (result[i].indexOf("TX") != -1) {

k++;

if (k == 2) {

txResult = result[i + 1].split(":")[1];

break;

}

} else { // 获取windows环境下的网口上下行速率

input.readLine();

tokenStat = new StringTokenizer(input.readLine());

tokenStat.nextToken();

rxResult = tokenStat.nextToken();

txResult = tokenStat.nextToken();

}

} catch (Exception e) {

log.error(e.getMessage());

}

String arr[] = { rxResult, txResult };

return arr;

}

/**

* 由于String.subString对汉字处理存在问题(把一个汉字视为一个字节)，因此在包含汉字的字符串时存在隐患，现调整如下：

* @param src

* 要截取的字符串

* @param start_idx

* 开始坐标(包括该坐标)

* @param end_idx

* 截止坐标(包括该坐标)

* @return

private String substring(String src, int start_idx, int end_idx) {

byte[] b = src.getBytes();

String tgt = "";

for (int i = start_idx; i <= end_idx; i++) {

tgt += (char) b[i];

}

return tgt;

}

/**

* 格式化浮点数(float 和 double)，保留两位小数

* @param obj

* @return

private String formatNumber(Object obj) {

String result = "";

if (obj.getClass().getSimpleName().equals("Float")) {

result = new Formatter().format("%.2f", (float) obj).toString();

} else if (obj.getClass().getSimpleName().equals("Double")) {

result = new Formatter().format("%.2f", (double) obj).toString();

}

return result;

}

/**

* 测试方法：监测java执行相关命令后是否能获取到结果集(注：此方法执行后会中断程序的执行，测试完后请注释掉)

* @param br

public void testGetInput(BufferedReader in) {

int y = 0;

try {

while ((y = in.read()) != -1) {

System.out.print((char) y);

}

} catch (IOException e) {

e.printStackTrace();

}

return;

}

class SysInfoAcquirerTimerTask extends TimerTask {

@Override

public void run() {

try {

System.out.println("任务开始：");

long startTime = System.currentTimeMillis();

int threadCount = getThreadCount();

String cpuRate = getCPURate(); // CPU使用率

String memoryRate = getMemoryRate(); // 内存占用率

JSONObject jsonObj = JSON.parseObject(getNetworkThroughput());

String upSpeed = jsonObj.getString("txPercent");// 上行速度

String downSpeed = jsonObj.getString("rxPercent"); // 下行速度

System.out.println("JVM PID：" + pid);

System.out.println("JVM 线程数：" + threadCount);

System.out.println("内存占用率：" + memoryRate + "%");

System.out.println("CPU使用率：" + cpuRate + "%");

System.out.println("上行速度：" + upSpeed + "MB/s 下行速度：" + downSpeed + "MB/s");

//后续操作为保存数据到数据库，可自己设计

SysPerformInfo sysPerformInfo = new SysPerformInfo();

sysPerformInfo.setId(UuidUtil.getUuid());

sysPerformInfo.setCpuRate(Float.parseFloat(cpuRate));

sysPerformInfo.setMemoryRate(Float.parseFloat(memoryRate));

sysPerformInfo.setThreadCount(threadCount);

sysPerformInfo.setUpSpeed(Float.parseFloat(upSpeed));

sysPerformInfo.setDownSpeed(Float.parseFloat(downSpeed));

sysPerformInfoService.insertPerformInfo(sysPerformInfo); // 将采集到的数据插入数据库

long endTime = System.currentTimeMillis();

System.out.println("任务总耗时：" + (endTime - startTime) / (1000 * 60) + "分钟");

} catch (Exception e) {

e.printStackTrace();

log.error(e.toString());

}

@PreDestroy

public void destroy() {

log.info("do nothing in @PreDestroy method");

}

若此文帮到您了，您开心的话就赏点饮水钱吧，苦逼的程序猿~哈哈

weixin_39716921

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫