Android中获取CPU负载和进程cpu时间

        android系统中有一个ProcessStats类,我们可以使用它来获取系统的负载情况及进程时间。

        实现原理是读取/proc目录下的。linux系统运行时,内核会去更新 /proc目录下的文件,将PID的运行情况写入相应的文件中。我们主要关注以下文件

1. /proc/stat

该文件包含了从系统启动开始累积到当前时刻的CPU活动信息。

看下我手机的情况,如下

cat /proc/stat

cpu  14869 5121 19794 156065 3114 0 26 0 0 0 

cpu0 10268 4823 15912 84682 2800 0 23 0 0 0

intr 8830975 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5926 0 0 0 0 0 0 0 0 0 0 0 0 0 0 84406

0 0 0 0 0 0 0 0 0 0 13205 0 2195 0 0 0 0 2 2 0 4304 0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 1570 0 321 0 7132798 0 3638 21 0 0 1 0 0 0 134 0 0 0 0 0 0 0

 0 0 0 0 715 835 0 0 168670 0 0 0 0 0 0 0 0 0 0 0 0 0 2124 28527 0 0 200 0 0 0 0

 4823 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

ctxt 15331839

btime 1423869515

processes 2813

procs_running 3

procs_blocked 1

softirq 135522 11 57942 11 3386 11 11 8212 5725 54 60159

cpu的每一列的意思如下

user (14869 ) 从系统启动开始累计到当前时刻,用户态的CPU时间(单位:jiffies) ,不包含 nice值为负进程。1jiffies=0.01秒
nice (5121 ) 从系统启动开始累计到当前时刻,nice值为负的进程所占用的CPU时间(单位:jiffies)
system (19794 ) 从系统启动开始累计到当前时刻,核心时间(单位:jiffies)
idle (156065 ) 从系统启动开始累计到当前时刻,除硬盘IO等待时间以外其它等待时间(单位:jiffies)
iowait (3114 ) 从系统启动开始累计到当前时刻,硬盘IO等待时间(单位:jiffies) ,
irq (0) 从系统启动开始累计到当前时刻,硬中断时间(单位:jiffies)
softirq (26) 从系统启动开始累计到当前时刻,软中断时间(单位:jiffies)

后三个android没有读取,估计没用。

手机是单核从,所以只有cup0,含义和上面一样

其他的如下:

“intr”这行给出中断的信息,第一个为自系统启动以来,发生的所有的中断的次数;然后每个数对应一个特定的中断自系统启动以来所发生的次数。
“ctxt”给出了自系统启动以来CPU发生的上下文交换的次数。
“btime”给出了从系统启动到现在为止的时间,单位为秒。
“processes (total_forks) 自系统启动以来所创建的任务的个数目。
“procs_running”:当前运行队列的任务的数目。
“procs_blocked”:当前被阻塞的任务的数目。


2./proc/loadavg

系统平均负载.该文件中的所有值都是从系统启动开始累计到当前时刻。该文件只给出了所有CPU的集合信息,不能该出每个CPU的信息。


我手机中如下:

cat /proc/loadavg

10.78 9.55 7.20 5/818 3719


每个值的含义为:
参数 解释
lavg_1 (10.78) 1-分钟平均负载
lavg_5 (9.55) 5-分钟平均负载
lavg_15(7.20) 15-分钟平均负载
nr_running (5) 在采样时刻,运行队列的任务的数目,与/proc/stat的procs_running表示相同意思
nr_threads (818) 在采样时刻,系统中活跃的任务的个数(不包括运行已经结束的任务)
last_pid(3719) 最大的pid值,包括轻量级进程,即线程。



3.进程信息

以PID作为文件夹名。

例如进程2411的stat如下

cat /proc/2411/stat

2411 (loop43) S 2 0 0 0 -1 2129984 0 0 0 0 0 150 0 0 0 -20 1 0 7794 0 0 42949672

95 0 0 0 0 0 0 0 2147483647 0 4294967295 0 0 17 2 0 0 0 0 0 0 0 0

每一项的含义可以看http://www.net527.cn/a/caozuoxitong/Linux/2012/0823/24385.html




有了以上的基础,我们就可以看ProcessStats这个类了。

update()函数读取上面所提的信息。

    public void update() {
        ......
        // 读取/proc/stat中的cpu时间
        if (Process.readProcFile("/proc/stat", SYSTEM_CPU_FORMAT,
                null, sysCpu, null)) {
            // Total user time is user + nice time.
            final long usertime = sysCpu[0]+sysCpu[1];
            // Total system time is simply system time.
            final long systemtime = sysCpu[2];
            // Total idle time is simply idle time.
            final long idletime = sysCpu[3];
            // Total irq time is iowait + irq + softirq time.
            final long iowaittime = sysCpu[4];
            final long irqtime = sysCpu[5];
            final long softirqtime = sysCpu[6];
 
            mRelUserTime = (int)(usertime - mBaseUserTime);
            mRelSystemTime = (int)(systemtime - mBaseSystemTime);
            mRelIoWaitTime = (int)(iowaittime - mBaseIoWaitTime);
            mRelIrqTime = (int)(irqtime - mBaseIrqTime);
            mRelSoftIrqTime = (int)(softirqtime - mBaseSoftIrqTime);
            mRelIdleTime = (int)(idletime - mBaseIdleTime);
 
            if (DEBUG) {
                Slog.i("Load", "Total U:" + sysCpu[0] + " N:" + sysCpu[1]
                      + " S:" + sysCpu[2] + " I:" + sysCpu[3]
                      + " W:" + sysCpu[4] + " Q:" + sysCpu[5]
                      + " O:" + sysCpu[6]);
                Slog.i("Load", "Rel U:" + mRelUserTime + " S:" + mRelSystemTime
                      + " I:" + mRelIdleTime + " Q:" + mRelIrqTime);
            }
 
            mBaseUserTime = usertime;
            mBaseSystemTime = systemtime;
            mBaseIoWaitTime = iowaittime;
            mBaseIrqTime = irqtime;
            mBaseSoftIrqTime = softirqtime;
            mBaseIdleTime = idletime;
        }
         // 读取所有/proc/[pid]/文件夹中的进行信息
        mCurPids = collectStats("/proc", -1, mFirst, mCurPids, mProcStats);
 
        // 读取/proc/loadavg中的平均负载
        final float[] loadAverages = mLoadAverageData;
        if (Process.readProcFile("/proc/loadavg", LOAD_AVERAGE_FORMAT,
                null, null, loadAverages)) {
            float load1 = loadAverages[0];
            float load5 = loadAverages[1];
            float load15 = loadAverages[2];
            if (load1 != mLoad1 || load5 != mLoad5 || load15 != mLoad15) {
                mLoad1 = load1;
                mLoad5 = load5;
                mLoad15 = load15;
                onLoadChanged(load1, load5, load15);
            }
        }
 
        if (DEBUG) Slog.i(TAG, "*** TIME TO COLLECT STATS: "
                + (SystemClock.uptimeMillis()-mCurrentSampleTime));
 
        mWorkingProcsSorted = false;
        mFirst = false;
    }




再来看下读取进行信息的函数

    private int[] collectStats(String statsFile, int parentPid, boolean first,
            int[] curPids, ArrayList<Stats> allProcs) {
        //获取全部PID
        int[] pids = Process.getPids(statsFile, curPids);
        int NP = (pids == null) ? 0 : pids.length;
        int NS = allProcs.size();
        int curStatsIndex = 0;
        //迭代PID,创建或更新PID对应的Stats对象
        for (int i=0; i<NP; i++) {
            int pid = pids[i];
            if (pid < 0) {
                NP = pid;
                break;
            }
            Stats st = curStatsIndex < NS ? allProcs.get(curStatsIndex) : null;
             // Stats对象已经存在,更新
            if (st != null && st.pid == pid) {
                // Update an existing process...
                st.added = false;
                st.working = false;
                curStatsIndex++;
                if (DEBUG) Slog.v(TAG, "Existing "
                        + (parentPid < 0 ? "process" : "thread")
                        + " pid " + pid + ": " + st);
 
                if (st.interesting) {
                    final long uptime = SystemClock.uptimeMillis();
 
                    final long[] procStats = mProcessStatsData;
                    // 读取/proc/[pid]/stat文件中的信息至procStats
                    if (!Process.readProcFile(st.statFile.toString(),
                            PROCESS_STATS_FORMAT, null, procStats, null)) {
                        continue;
                    }
                     
                    final long minfaults = procStats[PROCESS_STAT_MINOR_FAULTS];
                    final long majfaults = procStats[PROCESS_STAT_MAJOR_FAULTS];
                    final long utime = procStats[PROCESS_STAT_UTIME];
                    final long stime = procStats[PROCESS_STAT_STIME];
                     // cpu用户时间系统时间没变化,设置Stats的active为false
                    if (utime == st.base_utime && stime == st.base_stime) {
                        st.rel_utime = 0;
                        st.rel_stime = 0;
                        st.rel_minfaults = 0;
                        st.rel_majfaults = 0;
                        if (st.active) {
                            st.active = false;
                        }
                        continue;
                    }
 
                    if (!st.active) {
                        st.active = true;
                    }
 
                    if (parentPid < 0) {
                        // 从/proc/[pid]/cmdline中读取进程名
                        getName(st, st.cmdlineFile);
                        if (st.threadStats != null) {
                            // 如果需要读取线程信息,怎从/proc/[pid]/task/中读取全部线程的信息
                            mCurThreadPids = collectStats(st.threadsDir, pid, false,
                                    mCurThreadPids, st.threadStats);
                        }
                    }
 
                    if (DEBUG) Slog.v("Load", "Stats changed " + st.name + " pid=" + st.pid
                            + " utime=" + utime + "-" + st.base_utime
                            + " stime=" + stime + "-" + st.base_stime
                            + " minfaults=" + minfaults + "-" + st.base_minfaults
                            + " majfaults=" + majfaults + "-" + st.base_majfaults);
                     // 设置Stats的值
                    st.rel_uptime = uptime - st.base_uptime;
                    st.base_uptime = uptime;
                    st.rel_utime = (int)(utime - st.base_utime);
                    st.rel_stime = (int)(stime - st.base_stime);
                    st.base_utime = utime;
                    st.base_stime = stime;
                    st.rel_minfaults = (int)(minfaults - st.base_minfaults);
                    st.rel_majfaults = (int)(majfaults - st.base_majfaults);
                    st.base_minfaults = minfaults;
                    st.base_majfaults = majfaults;
                    st.working = true;
                }
 
                continue;
            }
             // Stats对象不存在,创建
            if (st == null || st.pid > pid) {
                ......
                // 创建的流程和更新差不多
                continue;
            }
                 
            ......
            continue;
        }
         ......
         
        return pids;
    }





我们可以很方便的使用这个类,来进行cpu负荷和进程时间的监控。Android系统在SystemUI中有一个服务,就使用了这个类。

我们看SystemUI的Manifest文件,可以找到一个叫LoadAverageService的服务,它就是使用了ProcessStats获取cpu和进程信息,并把他们显示出来。

最后,在看下如何使用LoadAverageService这个服务

可以在adb shell中直接运行am startservice -n com.android.systemui/.LoadAverageService

或者用【设置】->【开发者选项】->【显示cpu使用情况】打开服务

我们在开发应用的时候,可以开启这个选项,时时跟踪系统的cpu占用情况,真的是很方便啊!!!





郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。