Androidでメモリ使用量を取得
AndroidのCPUまたはメモリ使用量を取得できるAPIはありますか？
私は以下のように1つのコードを試しました：
package com.infostretch.mainactivity;
import Java.io.BufferedReader;
import Java.io.FileInputStream;
import Java.io.IOException;
import Java.io.InputStreamReader;
public class CPULoad
{
long total = 0;
long idle = 0;
float usage = 0;
public CPULoad()
{
readUsage();
}
public float getUsage()
{
readUsage();
return usage;
}
private void readUsage()
{
try
{
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("/proc/stat")), 1000);
String load = reader.readLine();
reader.close();
String[] toks = load.split(" ");
long currTotal = Long.parseLong(toks[2]) + Long.parseLong(toks[3]) + Long.parseLong(toks[4]);
long currIdle = Long.parseLong(toks[5]);
this.usage = (currTotal - total) * 100.0f / (currTotal - total + currIdle - idle);
this.total = currTotal;
this.idle = currIdle;
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
}
これは正しい方法ですか？
この関数を使用してCPU使用量を計算します。それがあなたを助けることを願っています。
private float readUsage() {
try {
RandomAccessFile reader = new RandomAccessFile("/proc/stat", "r");
String load = reader.readLine();
String[] toks = load.split(" +"); // Split on one or more spaces
long idle1 = Long.parseLong(toks[4]);
long cpu1 = Long.parseLong(toks[2]) + Long.parseLong(toks[3]) + Long.parseLong(toks[5])
+ Long.parseLong(toks[6]) + Long.parseLong(toks[7]) + Long.parseLong(toks[8]);
try {
Thread.sleep(360);
} catch (Exception e) {}
reader.seek(0);
load = reader.readLine();
reader.close();
toks = load.split(" +");
long idle2 = Long.parseLong(toks[4]);
long cpu2 = Long.parseLong(toks[2]) + Long.parseLong(toks[3]) + Long.parseLong(toks[5])
+ Long.parseLong(toks[6]) + Long.parseLong(toks[7]) + Long.parseLong(toks[8]);
return (float)(cpu2 - cpu1) / ((cpu2 + idle2) - (cpu1 + idle1));
} catch (IOException ex) {
ex.printStackTrace();
}
return 0;
}
CPU使用率を確認する簡単な方法は、adbツールw/topを使用することです。つまり：
adb Shell top -m 10
これまでの回答と個人的な経験に基づいて、CPU使用率を監視するために使用するコードを次に示します。このクラスのコードは、純粋なJavaで記述されています。
import Java.io.IOException;
import Java.io.RandomAccessFile;
/**
* Utilities available only on Linux Operating System.
*
* <p>
* A typical use is to assign a thread to CPU monitoring:
* </p>
*
* <pre>
* @Override
* public void run() {
* while (CpuUtil.monitorCpu) {
*
* LinuxUtils linuxUtils = new LinuxUtils();
*
* int pid = Android.os.Process.myPid();
* String cpuStat1 = linuxUtils.readSystemStat();
* String pidStat1 = linuxUtils.readProcessStat(pid);
*
* try {
* Thread.sleep(CPU_WINDOW);
* } catch (Exception e) {
* }
*
* String cpuStat2 = linuxUtils.readSystemStat();
* String pidStat2 = linuxUtils.readProcessStat(pid);
*
* float cpu = linuxUtils.getSystemCpuUsage(cpuStat1, cpuStat2);
* if (cpu >= 0.0f) {
* _printLine(mOutput, "total", Float.toString(cpu));
* }
*
* String[] toks = cpuStat1.split(" ");
* long cpu1 = linuxUtils.getSystemUptime(toks);
*
* toks = cpuStat2.split(" ");
* long cpu2 = linuxUtils.getSystemUptime(toks);
*
* cpu = linuxUtils.getProcessCpuUsage(pidStat1, pidStat2, cpu2 - cpu1);
* if (cpu >= 0.0f) {
* _printLine(mOutput, "" + pid, Float.toString(cpu));
* }
*
* try {
* synchronized (this) {
* wait(CPU_REFRESH_RATE);
* }
* } catch (InterruptedException e) {
* e.printStackTrace();
* return;
* }
* }
*
* Log.i("THREAD CPU", "Finishing");
* }
* </pre>
*/
public final class LinuxUtils {
// Warning: there appears to be an issue with the column index with Android linux:
// it was observed that on most present devices there are actually
// two spaces between the 'cpu' of the first column and the value of
// the next column with data. The thing is the index of the idle
// column should have been 4 and the first column with data should have index 1.
// The indexes defined below are coping with the double space situation.
// If your file contains only one space then use index 1 and 4 instead of 2 and 5.
// A better way to deal with this problem may be to use a split method
// not preserving blanks or compute an offset and add it to the indexes 1 and 4.
private static final int FIRST_SYS_CPU_COLUMN_INDEX = 2;
private static final int IDLE_SYS_CPU_COLUMN_INDEX = 5;
/** Return the first line of /proc/stat or null if failed. */
public String readSystemStat() {
RandomAccessFile reader = null;
String load = null;
try {
reader = new RandomAccessFile("/proc/stat", "r");
load = reader.readLine();
} catch (IOException ex) {
ex.printStackTrace();
} finally {
Streams.close(reader);
}
return load;
}
/**
* Compute and return the total CPU usage, in percent.
*
* @param start
* first content of /proc/stat. Not null.
* @param end
* second content of /proc/stat. Not null.
* @return 12.7 for a CPU usage of 12.7% or -1 if the value is not
* available.
* @see {@link #readSystemStat()}
*/
public float getSystemCpuUsage(String start, String end) {
String[] stat = start.split("\\s");
long idle1 = getSystemIdleTime(stat);
long up1 = getSystemUptime(stat);
stat = end.split("\\s");
long idle2 = getSystemIdleTime(stat);
long up2 = getSystemUptime(stat);
// don't know how it is possible but we should care about zero and
// negative values.
float cpu = -1f;
if (idle1 >= 0 && up1 >= 0 && idle2 >= 0 && up2 >= 0) {
if ((up2 + idle2) > (up1 + idle1) && up2 >= up1) {
cpu = (up2 - up1) / (float) ((up2 + idle2) - (up1 + idle1));
cpu *= 100.0f;
}
}
return cpu;
}
/**
* Return the sum of uptimes read from /proc/stat.
*
* @param stat
* see {@link #readSystemStat()}
*/
public long getSystemUptime(String[] stat) {
/*
* (from man/5/proc) /proc/stat kernel/system statistics. Varies with
* architecture. Common entries include: cpu 3357 0 4313 1362393
*
* The amount of time, measured in units of USER_HZ (1/100ths of a
* second on most architectures, use sysconf(_SC_CLK_TCK) to obtain the
* right value), that the system spent in user mode, user mode with low
* priority (Nice), system mode, and the idle task, respectively. The
* last value should be USER_HZ times the second entry in the uptime
* pseudo-file.
*
* In Linux 2.6 this line includes three additional columns: iowait -
* time waiting for I/O to complete (since 2.5.41); irq - time servicing
* interrupts (since 2.6.0-test4); softirq - time servicing softirqs
* (since 2.6.0-test4).
*
* Since Linux 2.6.11, there is an eighth column, steal - stolen time,
* which is the time spent in other operating systems when running in a
* virtualized environment
*
* Since Linux 2.6.24, there is a ninth column, guest, which is the time
* spent running a virtual CPU for guest operating systems under the
* control of the Linux kernel.
*/
// with the following algorithm, we should cope with all versions and
// probably new ones.
long l = 0L;
for (int i = FIRST_SYS_CPU_COLUMN_INDEX; i < stat.length; i++) {
if (i != IDLE_SYS_CPU_COLUMN_INDEX ) { // bypass any idle mode. There is currently only one.
try {
l += Long.parseLong(stat[i]);
} catch (NumberFormatException ex) {
ex.printStackTrace();
return -1L;
}
}
}
return l;
}
/**
* Return the sum of idle times read from /proc/stat.
*
* @param stat
* see {@link #readSystemStat()}
*/
public long getSystemIdleTime(String[] stat) {
try {
return Long.parseLong(stat[IDLE_SYS_CPU_COLUMN_INDEX]);
} catch (NumberFormatException ex) {
ex.printStackTrace();
}
return -1L;
}
/** Return the first line of /proc/pid/stat or null if failed. */
public String readProcessStat(int pid) {
RandomAccessFile reader = null;
String line = null;
try {
reader = new RandomAccessFile("/proc/" + pid + "/stat", "r");
line = reader.readLine();
} catch (IOException ex) {
ex.printStackTrace();
} finally {
Streams.close(reader);
}
return line;
}
/**
* Compute and return the CPU usage for a process, in percent.
*
* <p>
* The parameters {@code totalCpuTime} is to be the one for the same period
* of time delimited by {@code statStart} and {@code statEnd}.
* </p>
*
* @param start
* first content of /proc/pid/stat. Not null.
* @param end
* second content of /proc/pid/stat. Not null.
* @return the CPU use in percent or -1f if the stats are inverted or on
* error
* @param uptime
* sum of user and kernel times for the entire system for the
* same period of time.
* @return 12.7 for a cpu usage of 12.7% or -1 if the value is not available
* or an error occurred.
* @see {@link #readProcessStat(int)}
*/
public float getProcessCpuUsage(String start, String end, long uptime) {
String[] stat = start.split("\\s");
long up1 = getProcessUptime(stat);
stat = end.split("\\s");
long up2 = getProcessUptime(stat);
float ret = -1f;
if (up1 >= 0 && up2 >= up1 && uptime > 0.) {
ret = 100.f * (up2 - up1) / (float) uptime;
}
return ret;
}
/**
* Decode the fields of the file {@code /proc/pid/stat} and return (utime +
* stime)
*
* @param stat
* obtained with {@link #readProcessStat(int)}
*/
public long getProcessUptime(String[] stat) {
return Long.parseLong(stat[14]) + Long.parseLong(stat[15]);
}
/**
* Decode the fields of the file {@code /proc/pid/stat} and return (cutime +
* cstime)
*
* @param stat
* obtained with {@link #readProcessStat(int)}
*/
public long getProcessIdleTime(String[] stat) {
return Long.parseLong(stat[16]) + Long.parseLong(stat[17]);
}
/**
* Return the total CPU usage, in percent.
* <p>
* The call is blocking for the time specified by elapse.
* </p>
*
* @param elapse
* the time in milliseconds between reads.
* @return 12.7 for a CPU usage of 12.7% or -1 if the value is not
* available.
*/
public float syncGetSystemCpuUsage(long elapse) {
String stat1 = readSystemStat();
if (stat1 == null) {
return -1.f;
}
try {
Thread.sleep(elapse);
} catch (Exception e) {
}
String stat2 = readSystemStat();
if (stat2 == null) {
return -1.f;
}
return getSystemCpuUsage(stat1, stat2);
}
/**
* Return the CPU usage of a process, in percent.
* <p>
* The call is blocking for the time specified by elapse.
* </p>
*
* @param pid
* @param elapse
* the time in milliseconds between reads.
* @return 6.32 for a CPU usage of 6.32% or -1 if the value is not
* available.
*/
public float syncGetProcessCpuUsage(int pid, long elapse) {
String pidStat1 = readProcessStat(pid);
String totalStat1 = readSystemStat();
if (pidStat1 == null || totalStat1 == null) {
return -1.f;
}
try {
Thread.sleep(elapse);
} catch (Exception e) {
e.printStackTrace();
return -1.f;
}
String pidStat2 = readProcessStat(pid);
String totalStat2 = readSystemStat();
if (pidStat2 == null || totalStat2 == null) {
return -1.f;
}
String[] toks = totalStat1.split("\\s");
long cpu1 = getSystemUptime(toks);
toks = totalStat2.split("\\s");
long cpu2 = getSystemUptime(toks);
return getProcessCpuUsage(pidStat1, pidStat2, cpu2 - cpu1);
}
}
このクラスを悪用する方法はいくつかあります。 syncGetSystemCpuUsageまたはsyncGetProcessCpuUsageのいずれかを呼び出すことができますが、それぞれが呼び出しスレッドをブロックしています。一般的な問題は、CPUの合計使用量と現在のプロセスのCPU使用量を同時に監視することなので、両方を計算するクラスを設計しました。そのクラスには専用のスレッドが含まれています。出力管理は実装固有であり、独自にコーディングする必要があります。
クラスはいくつかの方法でカスタマイズできます。定数CPU_WINDOWは、読み取りの深さ、つまり読み取りから対応するCPU負荷の計算までのミリ秒数を定義します。 CPU_REFRESH_RATEは、各CPU負荷測定間の時間です。 CPU_REFRESH_RATEを0に設定しないでください。最初の読み取り後にスレッドが中断されます。
import Java.io.File;
import Java.io.FileNotFoundException;
import Java.io.FileOutputStream;
import Java.io.OutputStream;
import Android.app.Application;
import Android.os.Handler;
import Android.os.HandlerThread;
import Android.util.Log;
import my.app.LinuxUtils;
import my.app.Streams;
import my.app.TestReport;
import my.app.Utils;
public final class CpuUtil {
private static final int CPU_WINDOW = 1000;
private static final int CPU_REFRESH_RATE = 100; // Warning: anything but > 0
private static HandlerThread handlerThread;
private static TestReport output;
static {
output = new TestReport();
output.setDateFormat(Utils.getDateFormat(Utils.DATE_FORMAT_ENGLISH));
}
private static boolean monitorCpu;
/**
* Construct the class singleton. This method should be called in
* {@link Application#onCreate()}
*
* @param dir
* the parent directory
* @param append
* mode
*/
public static void setOutput(File dir, boolean append) {
try {
File file = new File(dir, "cpu.txt");
output.setOutputStream(new FileOutputStream(file, append));
if (!append) {
output.println(file.getAbsolutePath());
output.newLine(1);
// print header
_printLine(output, "Process", "CPU%");
output.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
/** Start CPU monitoring */
public static boolean startCpuMonitoring() {
CpuUtil.monitorCpu = true;
handlerThread = new HandlerThread("CPU monitoring"); //$NON-NLS-1$
handlerThread.start();
Handler handler = new Handler(handlerThread.getLooper());
handler.post(new Runnable() {
@Override
public void run() {
while (CpuUtil.monitorCpu) {
LinuxUtils linuxUtils = new LinuxUtils();
int pid = Android.os.Process.myPid();
String cpuStat1 = linuxUtils.readSystemStat();
String pidStat1 = linuxUtils.readProcessStat(pid);
try {
Thread.sleep(CPU_WINDOW);
} catch (Exception e) {
}
String cpuStat2 = linuxUtils.readSystemStat();
String pidStat2 = linuxUtils.readProcessStat(pid);
float cpu = linuxUtils
.getSystemCpuUsage(cpuStat1, cpuStat2);
if (cpu >= 0.0f) {
_printLine(output, "total", Float.toString(cpu));
}
String[] toks = cpuStat1.split(" ");
long cpu1 = linuxUtils.getSystemUptime(toks);
toks = cpuStat2.split(" ");
long cpu2 = linuxUtils.getSystemUptime(toks);
cpu = linuxUtils.getProcessCpuUsage(pidStat1, pidStat2,
cpu2 - cpu1);
if (cpu >= 0.0f) {
_printLine(output, "" + pid, Float.toString(cpu));
}
try {
synchronized (this) {
wait(CPU_REFRESH_RATE);
}
} catch (InterruptedException e) {
e.printStackTrace();
return;
}
}
Log.i("THREAD CPU", "Finishing");
}
});
return CpuUtil.monitorCpu;
}
/** Stop CPU monitoring */
public static void stopCpuMonitoring() {
if (handlerThread != null) {
monitorCpu = false;
handlerThread.quit();
handlerThread = null;
}
}
/** Dispose of the object and release the resources allocated for it */
public void dispose() {
monitorCpu = false;
if (output != null) {
OutputStream os = output.getOutputStream();
if (os != null) {
Streams.close(os);
output.setOutputStream(null);
}
output = null;
}
}
private static void _printLine(TestReport output, String process, String cpu) {
output.stampln(process + ";" + cpu);
}
}
OPはCPU使用量とメモリ使用量を尋ねたので（受け入れられた答えはCPU使用量を取得するためのテクニックのみを示しています）、ActivityManagerクラスと特にこの質問から受け入れられた答えをお勧めします： 現在のメモリ使用量を取得する方法アンドロイドで？
Debugクラスを確認してください。 http://developer.Android.com/reference/Android/os/Debug.html すなわちDebug.getNativeHeapAllocatedSize()
使用されているネイティブヒープを取得するメソッドがあります。つまり、アプリの外部ビットマップで使用されます。アプリが内部で使用しているヒープについては、Android SDKに付属し、Eclipseからも利用できるDDMSツールで確認できます。
ネイティブヒープ+ DDMSに示されているヒープは、アプリが割り当てている合計ヒープを構成します。
CPU使用率については、API/SDKを介して利用できるものがあるかどうかわかりません。