一、应用CPU实时统计
1.1CPU总使用情况
在proc/stat下有当前设备详细的CPU使用情况.详细格式如下:
CPU 152342 1421 28562 1600830 12389 553 273 0 0
CPU后面的几位数字的含义分别是
user 从系统启动开始累计到当前时刻,处于用户态的运行时间,不包含 nice值为负进程。
nice 从系统启动开始累计到当前时刻,nice值为负的进程所占用的CPU时间
system 从系统启动开始累计到当前时刻,处于核心态的运行时间
idle 从系统启动开始累计到当前时刻,除IO等待时间以外的其它等待时间
iowait 从系统启动开始累计到当前时刻,IO等待时间
irq 从系统启动开始累计到当前时刻,硬中断时间
softirq 从系统启动开始累计到当前时刻,软中断时间
所以totalCpuTime这个7个属性的和.
1.2当前应用的CPU使用情况
/proc/pid/stat下则是该pid的CPU使用情况.详细格式如下:
2341 (com.xxxx.xxxx) S 1131 1131 0 0 -1 3912246 12450 0 2 0 3321 612 0 0 20 0
其中3321 612的含义分别是:
3321:utime 该任务在用户运行状态的时间
612:stime 该任务在核心运行的时间
所以processCpuTime为这个两个个属性的和.
1.3应用的CPU占用
当前应用所占CPU的算法是:
100*(processCpuTimeNow - processCpuTimeLast)/(totalCpuTimeNow - totalCpuTimeLast)
- 1
- 2
二、应用内存占用统计
统计当前应用的内存占用的方式:
(1)从ActivityManager获得MemoryInfo
(2)从MemoryInfo里获得TotalPss:memInfo[0].getTotalPss(),其中TotalPss = dalvikPss + nativePss + otherPss
三、DEMO
开启一个周期性的任务打印实时CPU和内存占用
import android.app.ActivityManager;
import android.content.Context;
import android.os.Debug;
import android.os.Process;
import android.util.Log;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* Usage:
* Sampler.getInstance().init(getApplicationContext(), 100L);
* Sampler.getInstance().start();
*/
public class Sampler implements Runnable {
private volatile static Sampler instance = null;
private ScheduledExecutorService scheduler;
private ActivityManager activityManager;
private long freq;
private Long lastCpuTime;
private Long lastAppCpuTime;
private RandomAccessFile procStatFile;
private RandomAccessFile appStatFile;
private final String relativeSavePath = "sourceSummary.txt";
private String savePath;
private StringBuilder surveyBuffer;
private long count;
private Sampler() {
scheduler = Executors.newSingleThreadScheduledExecutor();
}
public static Sampler getInstance() {
if (instance == null) {
synchronized (Sampler.class) {
if (instance == null) {
instance = new Sampler();
}
}
}
return instance;
}
// freq为采样周期
public void init(Context context, long freq, String savePath) {
activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
this.freq = freq;
this.savePath = savePath + relativeSavePath;
surveyBuffer = new StringBuilder();
count = 1;
}
public void start() {
scheduler.scheduleWithFixedDelay(this, 0L, freq, TimeUnit.MILLISECONDS);
}
public void writeDown() {
try{
File saveFile = new File(savePath);
saveFile.createNewFile();
BufferedWriter writer = new BufferedWriter(new FileWriter(saveFile));
writer.write(surveyBuffer.toString());
writer.flush();
writer.close();
}
catch (IOException e){
e.printStackTrace();
}
}
@Override
public void run() {
double cpu = sampleCPU();
double mem = sampleMemory();
surveyBuffer.append(count++ + ": CPU: " + cpu + "%" + ", Memory: " + mem + "MB\r\n");
}
private double sampleCPU() {
long cpuTime;
long appTime;
double sampleValue = 0.0D;
try {
if (procStatFile == null || appStatFile == null) {
procStatFile = new RandomAccessFile("/proc/stat", "r");
appStatFile = new RandomAccessFile("/proc/" + Process.myPid() + "/stat", "r");
} else {
procStatFile.seek(0L);
appStatFile.seek(0L);
}
String procStatString = procStatFile.readLine();
String appStatString = appStatFile.readLine();
String procStats[] = procStatString.split(" ");
String appStats[] = appStatString.split(" ");
cpuTime = Long.parseLong(procStats[2]) + Long.parseLong(procStats[3])
+ Long.parseLong(procStats[4]) + Long.parseLong(procStats[5])
+ Long.parseLong(procStats[6]) + Long.parseLong(procStats[7])
+ Long.parseLong(procStats[8]);
appTime = Long.parseLong(appStats[13]) + Long.parseLong(appStats[14]);
if (lastCpuTime == null && lastAppCpuTime == null) {
lastCpuTime = cpuTime;
lastAppCpuTime = appTime;
return sampleValue;
}
sampleValue = ((double) (appTime - lastAppCpuTime) / (double) (cpuTime - lastCpuTime)) * 100D;
lastCpuTime = cpuTime;
lastAppCpuTime = appTime;
} catch (Exception e) {
e.printStackTrace();
}
return sampleValue;
}
private double sampleMemory() {
double mem = 0.0D;
try {
// 统计进程的内存信息 totalPss
final Debug.MemoryInfo[] memInfo = activityManager.getProcessMemoryInfo(new int[]{Process.myPid()});
if (memInfo.length > 0) {
// TotalPss = dalvikPss + nativePss + otherPss, in KB
final int totalPss = memInfo[0].getTotalPss();
if (totalPss >= 0) {
// Mem in MB
mem = totalPss / 1024.0D;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return mem;
}
}
转载自:https://blog.csdn.net/hello2mao/article/details/68503780