android 获取当前程序所占内存

AI算法网奇

已于 2023-09-08 01:35:15 修改

阅读量2.1k

点赞数 1

分类专栏： android开发文章标签： java jvm 开发语言

于 2023-09-05 01:53:14 首次发布

本文链接：https://blog.csdn.net/jacke121/article/details/132681452

版权

android开发专栏收录该内容

203 篇文章 8 订阅

订阅专栏

android jni中c++获取当前程序所占内存

可以使用 Runtime 类和 MemoryInfo 类。

获取特定进程（例如当前应用程序）的内存信息，可以使用 getProcessMemoryInfo 方法，

android java代码当cpu占用超过85，报警，内存占用超过85报警

获取cpu占用率的例子：

android jni中c++获取当前程序所占内存

在Android的JNI环境中，获取当前进程的内存使用情况需要通过读取 /proc/self/statm 文件来实现。这个文件包含了进程的内存使用情况的信息。以下是一个简单的C++函数，可以获取当前进程的内存使用情况：

#include <cstdio>

long getMemoryUsage() {
    FILE* file = fopen("/proc/self/statm", "r");
    if (file == nullptr) {
        return -1;
    }

    long size; //       total program size (pages) (same as VmSize in /proc/[pid]/status)
    long resident;//   resident set size (pages) (same as VmRSS in /proc/[pid]/status)
    long share;//      shared pages (i.e., backed by a file)
    long text;//       text (code)
    long lib;//        library (unused in Linux 2.6)
    long data;//       data + stack
    long dt;//         dirty pages (unused in Linux 2.6)

    int count = fscanf(file, "%ld %ld %ld %ld %ld %ld %ld", &size, &resident, &share, &text, &lib, &data, &dt);
    fclose(file);

    if (count != 7) {
        return -1;
    }

    // 注意: 这里获取的是以页为单位的内存使用情况，需要乘以页面大小才能转换为字节
    long page_size = sysconf(_SC_PAGESIZE);

    return resident * page_size;
}

这个函数会返回当前进程的内存使用情况（以字节为单位）。如果发生错误，它会返回-1。

这个函数获取的是进程的常驻集大小（Resident Set Size，RSS），这是进程在物理内存中占用的部分的大小。这不包括交换空间中的部分，也不包括共享的部分。

请注意，这个函数只适用于Linux和Android，不适用于其他操作系统。在Android上，你可能需要添加适当的权限才能读取 /proc/self/statm 文件。

可以使用 `Runtime` 类和 `MemoryInfo` 类。

以下是一个简单的示例：

import android.app.ActivityManager;
import android.content.Context;
import android.os.Debug;

...

// 获取 ActivityManager 服务
ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);

// 创建一个 MemoryInfo 对象
ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();

// 获取当前应用程序的内存信息
activityManager.getMemoryInfo(memoryInfo);

// 输出当前应用程序的内存使用情况
Log.i("Memory Info", "Memory usage: " + memoryInfo.availMem);

这段代码会输出当前应用程序的可用内存。请注意，这是整个应用程序的可用内存，而不仅仅是当前运行的Activity。

获取特定进程（例如当前应用程序）的内存信息，可以使用 `getProcessMemoryInfo` 方法，

如下所示：

// 获取当前应用程序的 PID
int pid = android.os.Process.myPid();

// 获取指定 PID 的内存信息
Debug.MemoryInfo[] memoryInfoArray = activityManager.getProcessMemoryInfo(new int[]{pid});

// 获取当前应用程序的总 PSS
int totalPss = memoryInfoArray[0].getTotalPss();

// 输出当前应用程序的内存使用情况
Log.i("Memory Info", "Memory usage: " + totalPss);

这段代码会输出当前应用程序的总 PSS（Proportional Set Size），这是一个表示应用程序实际使用的内存量的指标。

请注意，这些方法需要 android.permission.GET_TASKS 权限，你需要在你的 AndroidManifest.xml 文件中声明这个权限。

最后，需要注意的是，这些方法只能提供一个大概的内存使用情况，如果你需要更详细的内存使用情况，你可能需要使用更复杂的工具，例如 Android Profiler。

android java代码当cpu占用超过85，报警，内存占用超过85报警

public class MainActivity extends AppCompatActivity {

    private Handler mHandler = new Handler();
    private Runnable mRunnable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mRunnable = new Runnable() {
            @Override
            public void run() {
                double cpuUsage = getCpuUsage();
                double memoryUsage = getMemoryUsage();

                if (cpuUsage > 85) {
                    // CPU使用率超过85%，发出警告
                    Log.w("Warning", "CPU usage is over 85%: " + cpuUsage);
                }

                if (memoryUsage > 85) {
                    // 内存使用率超过85%，发出警告
                    Log.w("Warning", "Memory usage is over 85%: " + memoryUsage);
                }

                // 每隔一秒钟检查一次
                mHandler.postDelayed(this, 1000);
            }
        };

        mHandler.post(mRunnable);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacks(mRunnable);
    }

    private double getCpuUsage() {
        // 这里需要实现获取CPU使用率的逻辑
        // 可以使用 /proc/stat 和 /proc/[pid]/stat 文件
        return 0;
    }

    private double getMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long usedMemory = runtime.totalMemory() - runtime.freeMemory();
        long totalMemory = runtime.maxMemory();
        return 100.0 * usedMemory / totalMemory;
    }
}

获取cpu占用率的例子：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class MainActivity extends AppCompatActivity {

    private Handler mHandler = new Handler();
    private Runnable mRunnable;
    private long mLastCpuTime;
    private long mLastAppCpuTime;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mRunnable = new Runnable() {
            @Override
            public void run() {
                double cpuUsage = getCpuUsage();

                if (cpuUsage > 85) {
                    // CPU使用率超过85%，发出警告
                    Log.w("Warning", "CPU usage is over 85%: " + cpuUsage);
                }

                // 每隔一秒钟检查一次
                mHandler.postDelayed(this, 1000);
            }
        };

        mHandler.post(mRunnable);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacks(mRunnable);
    }

    private double getCpuUsage() {
        try {
            long cpuTime = readSystemCpuTime();
            long appCpuTime = readProcessCpuTime();

            long cpuTimeDiff = cpuTime - mLastCpuTime;
            long appCpuTimeDiff = appCpuTime - mLastAppCpuTime;

            mLastCpuTime = cpuTime;
            mLastAppCpuTime = appCpuTime;

            return 100.0 * appCpuTimeDiff / cpuTimeDiff;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    private long readSystemCpuTime() throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("/proc/stat"));
        String[] tokens = reader.readLine().split(" ");
        reader.close();

        long idleTime = Long.parseLong(tokens[4]);
        long totalTime = 0;
        for (int i = 2; i < tokens.length; i++) {
            totalTime += Long.parseLong(tokens[i]);
        }

        return totalTime - idleTime;
    }

    private long readProcessCpuTime() throws IOException {
        int pid = android.os.Process.myPid();
        BufferedReader reader = new BufferedReader(new FileReader("/proc/" + pid + "/stat"));
        String[] tokens = reader.readLine().split(" ");
        reader.close();

        long utime = Long.parseLong(tokens[13]);
        long stime = Long.parseLong(tokens[14]);
        long cutime = Long.parseLong(tokens[15]);
        long cstime = Long.parseLong(tokens[16]);

        return utime + stime + cutime + cstime;
    }
}