`

Android中获取系统内存信息以及进程信息-----ActivityManager的使用(一)

 
阅读更多

http://blog.csdn.net/qinjuning

 

本节内容主要是讲解ActivityManager的使用,通过ActivityManager我们可以获得系统里正在运行的activities,包括

     进程 (Process)等、应用程序/包、服务(Service)、任务(Task)信息。

 

              计划如下:

                  第一部分:获取系统可用内存以及所有的正在运行的进程信息 ;

                  第二部分:获取每个进程里运行的应用程序信息和所有正在运行的应用程序

                  第三部分:获取正在运行的服务和任务信息。

 

        

                每部分都准备了相应的Demo,助您更深的理解.

 

           

        知识准备:Android 应用程序模块: 应用、任务、进程 的知识介绍:

 

            1  一个android 包 (简称.apk ) :里面包含应用程序的代码以及资源。这是一个应用发布,用户能下载并安装他们

              设备上的文件。

            2  一个 任务 :通常用户能当它为一个“应用程序”来启动:通常在桌面上会有一个图标可以来启动任务,这是一个

              上层的应 用,可以将你的任务切换到前台来。

            3  一个 进程 :是一个底层的代码运行级别的核心进程。通常.apk包里所有代码运行在一个进程里,一个进程对于

              一个.apk包;然而, 进程 标签常用来改变代码运行的位置,可以是 全部的.apk包 或者是独立的 活动 , 接收器 , 服务 , 或者

                 提供器 组件。

  进程

         在Android中,进程是应用程序的完整实现,而不是用户通常了解的那样。他们主要用途很简单:

            1、提高稳定性和安全性,将不信任或者不稳定的代码移动到其他进程。

            2、可将多个.apk包运行在同一个进程里减少系统开销。

            3、帮助系统管理资源,将重要的代码放在一个单独的进程里,这样就可以单独销毁应用程序的其他部分。

 

         于是,为了完成某一任务或者减少系统资源的开销,一个进程里可以运行一个或多个应用程序

 

     

    更多知识点获取,请访问:《Android 应用程序模块: 应用, 任务, 进程, 和线程

 

 

ActivityManager 类:

             获取方法 ActivityManager mActivityManager (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);

 

          常用的静态内部类如下 (下面具体介绍):

 

                     ActivityManager.MemoryInfo : 系统可用内存信息

                      ActivityManager.RecentTaskInfo : 最近的任务信息

                      ActivityManager.RunningAppProcessInfo : 正在运行的进程信息

                      ActivityManager.RunningServiceInfo : 正在运行的服务信息

                      ActivityManager.RunningTaskInfo : 正在运行的任务信息

 

 

 常用方法:

public void getMemoryInfo (ActivityManager.MemoryInfo outInfo)

                说明:获取系统可用内存信息,数据封装在outInfo对象上

 

public Debug.MemoryInfo getProcessMemoryInfo (int[ ] pids

      说明:获取每个进程ID(集合)占用的内存大小(集合), pid和MemoryInfo是一一对应的。

     参数: pids 进程ID的集合             

PS :我们可以通过调用Debug.MemoryInfo 的dalvikPrivateDirty 字段获取进程占用的内存大小(单位为KB)

 

 public List<ActivityManager.RunningAppProcessInfo>getRunningAppProcess ()

    说明: 获取系统里正在运行的进程

public List < ActivityManager.RunningServiceInfo > getRunningServices (int maxNum)

     说明: 获取系统里所有正在运行的服务          

     参数:可能服务的最大值(赋予一常数即可,20、50都OK)

public List < ActivityManager.RunningTaskInfoo > getRunningTasks (int maxNum)

               说明:获取系统里正在运行的服务

               参数: 同上

 

public List < ActivityManager.RecentTaskInfo > getRecentTasks (int maxNum, int flags)

             说明:获取系统里最近启动的任务

             参数: 同上,flags一般为0即可

 

public voidkillBackgroundProcess (String packageName)

            说明:立即杀掉给定包名的进程,释放进程占用的资源(内存等),如果需要,系统会再次重新启动该进程。系统

            PS:系统进程是杀不死的,只能杀死用户进程 。但我没有找到好的方法辨别系统进程还是用户进程。但可以肯定的是,

                   能 够杀死的一定是用户进程。

 

          public void restartPackage(String packageName)

            说明:该方法已弃用,等同于killBackgroundProcess 。

 

 

 

 ActivityManager.MemoryInfo类

    常用字段:

            long availMem 系统可用内存

            long threshold 系统内存不足的阀值,即临界值

            boolean lowMemory 如果当前可用内存<= threshold ,该值为真

 

 

ActivityManager.RunningAppProcessInfo类

   常用字段:

          int pid                             进程ID

          int uid                             进程所在的用户ID

          String processName    进程名,默认是包名或者由android:process=””属性指定

          String [ ] pkgList           运行在该进程下的所有应用程序包名

 

       ActivityManager.RecentTaskInfo ActivityManager.RunningServiceInfo ActivityManager.RunningTaskInfo

   类的介绍 留在后文介绍。

 

 

 

DEMO说明:

          我们通过ActivityManager获取了系统的可用内存信息以及正在运行在系统里的进程具体信息,当然你也可以选择

       手动杀死 这些进程,不过前提是用户进程,因为系统进程是杀不死的。

 

          模拟器上的截图如下:

                                    

 

 

 

资源文件什么的就不再贴代码了,直接列出逻辑文件。

 

 

  获取系统可用内存的代码 :MainActivity.java

 

  1. package  com.qin.ammp;  
  2.   
  3.   
  4. import  java.util.ArrayList;  
  5. import  java.util.List;  
  6.   
  7. import  android.app.Activity;  
  8. import  android.app.ActivityManager;  
  9. import  android.app.ActivityManager.MemoryInfo;  
  10. import  android.content.Context;  
  11. import  android.content.Intent;  
  12. import  android.os.Bundle;  
  13. import  android.os.Debug;  
  14. import  android.text.format.Formatter;  
  15. import  android.util.Log;  
  16. import  android.view.View;  
  17. import  android.widget.Button;  
  18. import  android.widget.TextView;  
  19.   
  20. public   class  MainActivity  extends  Activity {  
  21.       
  22.     private   static  String TAG =  "AM_MEMORYIPROCESS"  ;  
  23.       
  24.     private  ActivityManager mActivityManager =  null  ;  
  25.       
  26.     private  TextView tvAvailMem  ;  
  27.     private  Button btProcessInfo ;  
  28.       
  29.     /** Called when the activity is first created. */   
  30.     @Override   
  31.     public   void  onCreate(Bundle savedInstanceState) {  
  32.         super .onCreate(savedInstanceState);  
  33.         setContentView(R.layout.main);  
  34.           
  35.         tvAvailMem = (TextView)findViewById(R.id.tvAvailMemory) ;  
  36.         btProcessInfo =(Button)findViewById(R.id.btProcessInfo);  
  37.         //跳转到显示进程信息界面   
  38.         btProcessInfo.setOnClickListener(new  View.OnClickListener() {  
  39.               
  40.             @Override   
  41.             public   void  onClick(View v) {  
  42.                 // TODO Auto-generated method stub   
  43.                 Intent intent = new  Intent(MainActivity. this ,BrowseProcessInfoActivity. class );  
  44.                 startActivity(intent);  
  45.             }  
  46.         });                 
  47.           
  48.         //获得ActivityManager服务的对象   
  49.         mActivityManager = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);  
  50.         
  51.         //获得可用内存信息   
  52.         String availMemStr = getSystemAvaialbeMemorySize();  
  53.         Log.i(TAG, "The Availabel Memory Size is" +availMemStr);   
  54.         //显示   
  55.         tvAvailMem.setText(availMemStr);   
  56.           
  57.     }  
  58.     //获得系统可用内存信息   
  59.     private  String getSystemAvaialbeMemorySize(){  
  60.         //获得MemoryInfo对象   
  61.         MemoryInfo memoryInfo = new  MemoryInfo() ;  
  62.         //获得系统可用内存,保存在MemoryInfo对象上   
  63.         mActivityManager.getMemoryInfo(memoryInfo) ;  
  64.         long  memSize = memoryInfo.availMem ;  
  65.           
  66.         //字符类型转换   
  67.         String availMemStr = formateFileSize(memSize);  
  68.           
  69.         return  availMemStr ;  
  70.     }  
  71.     
  72.     //调用系统函数,字符串转换 long -String KB/MB   
  73.     private  String formateFileSize( long  size){  
  74.         return  Formatter.formatFileSize(MainActivity. this , size);   
  75.     }  
  76.       
  77. }  


获取系统进程信息的代码 :BrowseProcessInfoActivity .java

 

  1. package  com.qin.ammp;  
  2.   
  3. import  java.util.ArrayList;  
  4. import  java.util.List;  
  5.   
  6. import  android.app.Activity;  
  7. import  android.app.ActivityManager;  
  8. import  android.app.AlertDialog;  
  9. import  android.app.Dialog;  
  10. import  android.content.Context;  
  11. import  android.content.DialogInterface;  
  12. import  android.os.Bundle;  
  13. import  android.os.Debug;  
  14. import  android.util.Log;  
  15. import  android.view.ContextMenu;  
  16. import  android.view.Menu;  
  17. import  android.view.MenuItem;  
  18. import  android.view.View;  
  19. import  android.view.ContextMenu.ContextMenuInfo;  
  20. import  android.widget.AdapterView;  
  21. import  android.widget.ListView;  
  22. import  android.widget.TextView;  
  23. import  android.widget.AdapterView.OnItemClickListener;  
  24.   
  25. public   class  BrowseProcessInfoActivity  extends  Activity   implements  OnItemClickListener{  
  26.   
  27.     private   static  String TAG =  "ProcessInfo" ;  
  28.     private   static   final   int  KILL_PORCESS =  1 ;  
  29.     private   static   final   int  SEARCH_RUNNING_APP =  2 ;  
  30.   
  31.     private  ActivityManager mActivityManager =  null ;  
  32.     // ProcessInfo Model类 用来保存所有进程信息   
  33.     private  List<ProcessInfo> processInfoList =  null ;  
  34.   
  35.     private  ListView listviewProcess;  
  36.     private  TextView tvTotalProcessNo ;   
  37.       
  38.     public   void  onCreate(Bundle savedInstanceState) {  
  39.         super .onCreate(savedInstanceState);  
  40.   
  41.         setContentView(R.layout.browse_process_list);  
  42.   
  43.         listviewProcess = (ListView) findViewById(R.id.listviewProcess);  
  44.         listviewProcess.setOnItemClickListener(this );  
  45.           
  46.         tvTotalProcessNo =(TextView)findViewById(R.id.tvTotalProcessNo);  
  47.           
  48.         this .registerForContextMenu(listviewProcess);  
  49.         // 获得ActivityManager服务的对象   
  50.         mActivityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);  
  51.         // 获得系统进程信息   
  52.         getRunningAppProcessInfo();  
  53.         // 为ListView构建适配器对象   
  54.         BrowseProcessInfoAdapter mprocessInfoAdapter = new  BrowseProcessInfoAdapter(  
  55.                 this , processInfoList);  
  56.         listviewProcess.setAdapter(mprocessInfoAdapter);  
  57.       
  58.         tvTotalProcessNo.setText("当前系统进程共有:" +processInfoList.size());  
  59.     }  
  60.     //杀死该进程,并且刷新   
  61.     @Override   
  62.     public   void  onItemClick(AdapterView<?> arg0, View arg1,   final   int  position,  long  arg3) {  
  63.         // TODO Auto-generated method stub   
  64.         new  AlertDialog.Builder( this ).setMessage( "是否杀死该进程" )  
  65.         .setPositiveButton("确定" new  DialogInterface.OnClickListener() {  
  66.               
  67.             @Override   
  68.             public   void  onClick(DialogInterface dialog,  int  which) {  
  69.                 // TODO Auto-generated method stub   
  70.                 //杀死该进程,释放进程占用的空间   
  71.                 mActivityManager.killBackgroundProcesses(processInfoList.get(position).getProcessName());  
  72.                            //刷新界面   
  73.                 getRunningAppProcessInfo() ;  
  74.                 BrowseProcessInfoAdapter mprocessInfoAdapter = new  BrowseProcessInfoAdapter(  
  75.                         BrowseProcessInfoActivity.this , processInfoList);  
  76.                 listviewProcess.setAdapter(mprocessInfoAdapter);  
  77.                 tvTotalProcessNo.setText("当前系统进程共有:" +processInfoList.size());  
  78.   
  79.             }  
  80.         }).setNegativeButton("取消" new  DialogInterface.OnClickListener() {  
  81.               
  82.             @Override   
  83.             public   void  onClick(DialogInterface dialog,  int  which) {  
  84.                 // TODO Auto-generated method stub   
  85.                 dialog.cancel() ;  
  86.             }  
  87.         }).create().show() ;  
  88.     }  
  89.     // 获得系统进程信息   
  90.     private   void  getRunningAppProcessInfo() {  
  91.         // ProcessInfo Model类   用来保存所有进程信息   
  92.         processInfoList = new  ArrayList<ProcessInfo>();  
  93.   
  94.         // 通过调用ActivityManager的getRunningAppProcesses()方法获得系统里所有正在运行的进程   
  95.         List<ActivityManager.RunningAppProcessInfo> appProcessList = mActivityManager  
  96.                 .getRunningAppProcesses();  
  97.   
  98.         for  (ActivityManager.RunningAppProcessInfo appProcessInfo : appProcessList) {  
  99.             // 进程ID号   
  100.             int  pid = appProcessInfo.pid;  
  101.             // 用户ID 类似于Linux的权限不同,ID也就不同 比如 root等   
  102.             int  uid = appProcessInfo.uid;  
  103.             // 进程名,默认是包名或者由属性android:process=""指定   
  104.             String processName = appProcessInfo.processName;  
  105.             // 获得该进程占用的内存   
  106.             int [] myMempid =  new   int [] { pid };  
  107.             // 此MemoryInfo位于android.os.Debug.MemoryInfo包中,用来统计进程的内存信息   
  108.             Debug.MemoryInfo[] memoryInfo = mActivityManager  
  109.                     .getProcessMemoryInfo(myMempid);  
  110.             // 获取进程占内存用信息 kb单位   
  111.             int  memSize = memoryInfo[ 0 ].dalvikPrivateDirty;  
  112.   
  113.             Log.i(TAG, "processName: "  + processName +  "  pid: "  + pid  
  114.                     + " uid:"  + uid +  " memorySize is -->"  + memSize +  "kb" );  
  115.             // 构造一个ProcessInfo对象   
  116.             ProcessInfo processInfo = new  ProcessInfo();  
  117.             processInfo.setPid(pid);  
  118.             processInfo.setUid(uid);  
  119.             processInfo.setMemSize(memSize);  
  120.             processInfo.setPocessName(processName);  
  121.             processInfoList.add(processInfo);  
  122.   
  123.             // 获得每个进程里运行的应用程序(包),即每个应用程序的包名   
  124.             String[] packageList = appProcessInfo.pkgList;  
  125.             Log.i(TAG, "process id is "  + pid +  "has "  + packageList.length);  
  126.             for  (String pkg : packageList) {  
  127.                 Log.i(TAG, "packageName "  + pkg +  " in process id is -->" + pid);  
  128.             }  
  129.         }  
  130.     }  
  131.   
  132.     public   void  onCreateContextMenu(ContextMenu menu, View v,  
  133.             ContextMenuInfo menuInfo) {  
  134.         menu.add(0 0 , KILL_PORCESS,  "杀死该进程" );  
  135.         menu.add(0 0 , SEARCH_RUNNING_APP,  "运行在该进程的应用程序" );  
  136.         super .onCreateContextMenu(menu, v, menuInfo);  
  137.   
  138.     }  
  139.   
  140.     public   boolean  onContextItemSelected(MenuItem item) {  
  141.         switch  (item.getItemId()) {  
  142.         case  KILL_PORCESS:  // 杀死该进程 , 重新加载界面   
  143.             new  AlertDialog.Builder( this ).setMessage( "是否杀死该进程" )  
  144.             .setPositiveButton("确定" new  DialogInterface.OnClickListener() {  
  145.                   
  146.                 @Override   
  147.                 public   void  onClick(DialogInterface dialog,  int  which) {  
  148.                     // TODO Auto-generated method stub   
  149.                       
  150.                 }  
  151.             }).setNegativeButton("取消" new  DialogInterface.OnClickListener() {  
  152.                   
  153.                 @Override   
  154.                 public   void  onClick(DialogInterface dialog,  int  which) {  
  155.                     // TODO Auto-generated method stub   
  156.                     dialog.cancel() ;  
  157.                 }  
  158.             }).create().show() ;  
  159.             break ;  
  160.         case  SEARCH_RUNNING_APP:  // 查看运行在该进程的应用程序信息   
  161.             break ;  
  162.         default :  
  163.             break ;  
  164.         }  
  165.         return   super .onContextItemSelected(item);  
  166.     }  
  167.   
  168. }  


   我们可以通过进程占用内存大小来进而获取占用cpu大小,直接换算还是很简单的。

 

  

   源代码地址: http://download.csdn.net/detail/qinjuning/3803314

 

分享到:
评论

相关推荐

    Android中获取系统内存信息以及进程信息

    在本篇文章中,我们将深入探讨如何利用`ActivityManager`获取内存信息和进程信息。 首先,我们来看如何获取系统内存信息。Android提供了一个名为`ActivityManager.RunningAppProcessInfo`的类,其中包含了关于当前...

    Android系统中如何获取系统进程信息

    ### Android系统中如何获取系统进程信息 在Android开发过程中,获取系统进程信息是实现设备监控、性能优化等应用功能的基础。本文将详细介绍如何利用Android提供的API来获取系统进程信息,并展示一个简易进程管理器...

    Android获取cpu,内存,磁盘使用率信息

    在Android平台上,获取CPU、内存和磁盘使用率信息对于开发者来说是十分重要的,这有助于监控设备性能,优化应用运行,以及提供用户友好的反馈。然而,由于Android系统的安全机制,不同的权限级别决定了你能获取到何...

    Android获取当前应用分配的最大内存和目前使用内存的方法

    在Android里,程序内存被分为2部分:native和dalvik,dalvik就是我们普通的Java使用内存,分析堆栈的时候使用的内存。我们创建的对象是在这里面分配的,对于内存的限制是 native+dalvik 不能超过最大限制. Android ...

    android 获取cpu使用率, 内存 实时数据

    在Android中,获取CPU使用率通常需要读取 `/proc/stat` 文件,该文件包含了系统运行的各种统计信息。以下是一个简单的示例,展示如何计算CPU使用率: ```java public float getCpuUsage() { String[] cpuUsage = ...

    Android中获取正在运行的应用程序ActivityManager的使用(二)

    本篇文章将深入探讨如何利用ActivityManager来获取正在运行的应用程序信息,这是Android开发中的一个重要知识点,对于理解和优化应用行为有着至关重要的作用。 首先,我们需要理解ActivityManager的核心职责。它...

    android api code学习之ActivityManager

    - ActivityManager也参与到Android系统的进程管理中,根据内存状态和Activity的重要程度决定哪些进程应该被杀死以释放资源。 5. **应用信息获取**: - 可以通过ActivityManager获取系统中所有已安装应用的信息,...

    Android 低版本和高版本获取后台运行进程

    尽管可以通过`ActivityManager`获取进程信息,但请注意,Android系统可能会根据内存状况杀死后台进程,所以获取到的进程列表并不一定完整。此外,对于非系统应用,获取其他应用的详细信息(尤其是敏感的后台信息)...

    Android 5.0系统以上获取运行进程demo

    在Android系统中,开发者经常需要获取设备上正在运行的进程信息,以便进行性能监控、内存管理或者优化应用的运行效率。然而,随着Android版本的更新,为了提高系统的安全性和隐私保护,Google对某些API进行了限制。...

    android 7.1 获取各个应用的各种内存信息的app demo

    5. **Linux命令**: Android系统基于Linux,因此也可以通过执行`cat /proc/pid/status`命令获取特定进程的内存使用信息。这需要通过`Runtime.getRuntime().exec()`来执行shell命令,但请注意这可能会带来安全风险。 ...

    Android悬浮窗--获取内存

    在Android开发中,实现一个悬浮窗并获取设备的内存信息是一项常见的需求,这通常涉及到UI设计、系统权限处理以及系统API的使用。本教程将详细讲解如何创建Android悬浮窗以及如何获取设备的内存信息。 首先,创建...

    Android项目实战--手机卫士27--拿到剩余内存以及正在运行的进程数

    然后在代码中,我们可以这样获取内存信息: ```java ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE); ActivityManager.MemoryInfo memoryInfo = new ActivityManager...

    解决getRunningAppProcesses只得到本应用的进程的问题(2)

    在Android开发中,有时我们需要获取设备上正在运行的应用进程信息,比如进行性能分析或优化内存使用。然而,当你尝试使用`ActivityManager.getRunningAppProcesses()`方法时,可能会遇到一个问题:这个方法默认只会...

    Android项目实战--手机卫士28--读取进程的信息并显示出来

    总的来说,"Android项目实战--手机卫士28--读取进程的信息并显示出来"这一课题涉及到Android权限管理、系统服务的使用、UI设计与交互以及性能优化等多个核心知识点。通过这个项目,开发者不仅可以提升Android编程...

    获取android手机内存

    在Android系统中,获取手机内存信息是开发过程中的一项常见任务,这有助于监控设备性能或优化应用程序资源使用。本文将深入探讨如何在Android中获取并显示内存信息,主要围绕以下几个方面展开: 1. **Android内存...

    android系统数据信息获取

    本主题将详细探讨如何获取Android系统中的GPS定位信息、短信内容、通话记录、通信状态、进程详情、内存占用以及CPU使用情况。 1. **GPS定位信息获取**: Android提供了`LocationManager`类来获取GPS位置信息。通过...

    Android获取正在运行程序并kill掉

    标题"Android获取正在运行程序并kill掉"涉及的关键知识点主要包括Android进程管理、系统权限、以及如何编程实现这个功能。以下将详细介绍这些内容。 首先,Android系统中的进程分为多个级别,如前台进程、可见进程...

Global site tag (gtag.js) - Google Analytics