 上传我的文档
 下载
 收藏
免责声明：本人所有资料来自网络和个人所创，版权归原作者所有，请注意保护知识产权，如有需要请购买正版图书，请您下载后勿作商用，于24小时内删除，本人所提供资料仅为方便学习交流。 本人如有侵犯作者权益，请作者联系官方或本人,本人将立即删除。
 下载此文档
正在努力加载中...
C#如何实现获取电脑硬件配置信息
下载积分：600
内容提示：C#如何实现获取电脑硬件配置信息
文档格式：DOC|
浏览次数：118|
上传日期： 14:07:31|
文档星级：
全文阅读已结束，如果下载本文需要使用
 600 积分
下载此文档
该用户还上传了这些文档
C#如何实现获取电脑硬件配置信息
关注微信公众号如何获取操作系统信息_百度知道
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。
如何获取操作系统信息
我有更好的答案
jpg" esrc="http./zhidao/wh%3D450%2C600/sign=ec7c2b08099c6befa187/242dd42ab2d2dfc3ea15ce36d3be30://b.com/zhidao/pic/item/242dd42ab2d2dfc3ea15ce36d3be30.jpg" target="_blank" title="点击查看大图" class="ikqb_img_alink"><img class="ikqb_img" src="http.baidu用命令“systeminfo”可以看到系统信息如版本、初次安装时间等，还可看到系统的其他信息非常有用<a href="http://b.hiphotos://b./zhidao/wh%3D600%2C800/sign=eeef01f4dceb51d/242dd42ab2d2dfc3ea15ce36d3be30
采纳率：51%
来自团队：
建议下载鲁大师帮助您查看电脑上的信息和配置。
右键”我的电脑“（此电脑）--属性
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包比特客户端
您的位置：
详解大数据
详解大数据
详解大数据
详解大数据
Linux下应如何获取磁盘信息
下如何获取信息熟悉Linux的都知道，Linux下硬盘的命名规则是had、hdb…sda、sdb之类的。但是，如何才能知道机器上到底有多少块硬盘呢？
刚开始，我以为/dev目录下会有所体现结果我发现设备文件存在并不代表这个设备。那么怎么办才好呢。后来我发现fdisk可以得到硬盘的数量。于是就阅读了一下fdisk的源代码。果然找到了Linux获取硬盘数量的方法。实例代码如下：
#include
#include
int GetDiskCount()
FILE* f = fopen(“/proc/partitions”， “r”);
if (!f)
fprintf(stderr， “fopen /proc/partitions failed!errno=%d\n”， errno);
return 0;
char line[100]， ptname[100]， devname[120]， *s;
int ma， mi，
int nDiskCount = 0;
while (fgets(line， sizeof(line)， f))
if (sscanf(line， “ %u %u %u %[^\n ]”，
&ma， &mi， &sz， ptname) != 4)
for (s = *s; s++)
/*： excluding ‘0’： e.g. mmcblk0 is not a partition name! */
if (s[-1] 》= ‘1’ && s[-1] 《= ‘9’)
nDiskCount++;
fclose(f);
return nDiskC
int main(int argc， char * argv[])
printf(“DiskCount： %d\n”， GetDiskCount());
return 0;
其实，原理很简单。就是通过proc文件系统获得。在proc文件系统中有一个名为partitions的文件。这个文件中包含本地磁盘的硬盘及分区信息。根据Linux下设备命名规则，如果设备名的最后一个字符是数字就应该是分区，否则就是硬盘。于是，我们就可以轻而易举的知道电脑中有几个硬盘。
当然，根据这个文件，还可以知道硬盘设备名称以及每个硬盘中分区的数量和每个分区的设备名称。至于如何获取，大家应该都会的。
获取硬盘信息：
现在，我们已经可以知道硬盘数量、硬盘的设备名称、分区数及分区的设备名称。那么，怎么才能知道这些设备的信息呢？比如硬盘大小、扇区大小、分区大小、分区已经使用的大小等等。
关于硬盘的信息，在fdisk的源码中也可以找到相关的源码。实例代码如下：
#include
#include
int GetDiskCount()
FILE* f = fopen(“/proc/partitions”， “r”);
if (!f)
fprintf(stderr， “fopen /proc/partitions failed!errno=%d\n”， errno);
return 0;
char line[100]， ptname[100]， devname[120]， *s;
int ma， mi，
int nDiskCount = 0;
while (fgets(line， sizeof(line)， f))
if (sscanf(line， “ %u %u %u %[^\n ]”，
&ma， &mi， &sz， ptname) != 4)
for (s = *s; s++)
/* note： excluding ‘0’： e.g. mmcblk0 is not a partition name! */
if (s[-1] 》= ‘1’ && s[-1] 《= ‘9’)
nDiskCount++;
fclose(f);
return nDiskC
int main(int argc， char * argv[])
printf(“DiskCount： %d\n”， GetDiskCount());
return 0;
其实，就是通过打开设备文件然后分别调用ioctl来获取硬盘的大小、扇区大小、CHS信息等等。程序运行结果如下：
user：~/$sudo 。/diskinfo /dev/sda
Disk /dev/sda infomation：
Size：
Bytes 40.00 GB
SectorSize： 512 Bytes
heads： 255
sectors： 63
cylinders： 5221
start： 0
[ 责任编辑：之极 ]
去年，手机江湖里的竞争格局还是…
甲骨文的云战略已经完成第一阶段…
软件信息化周刊
比特软件信息化周刊提供以数据库、操作系统和管理软件为重点的全面软件信息化产业热点、应用方案推荐、实用技巧分享等。以最新的软件资讯，最新的软件技巧，最新的软件与服务业内动态来为IT用户找到软捷径。
商务办公周刊
比特商务周刊是一个及行业资讯、深度分析、企业导购等为一体的综合性周刊。其中，与中国计量科学研究院合力打造的比特实验室可以为商业用户提供最权威的采购指南。是企业用户不可缺少的智选周刊！
比特网络周刊向企业网管员以及网络技术和产品使用者提供关于网络产业动态、技术热点、组网、建网、网络管理、网络运维等最新技术和实用技巧，帮助网管答疑解惑，成为网管好帮手。
服务器周刊
比特服务器周刊作为比特网的重点频道之一，主要关注x86服务器，RISC架构服务器以及高性能计算机行业的产品及发展动态。通过最独到的编辑观点和业界动态分析，让您第一时间了解服务器行业的趋势。
比特存储周刊长期以来，为读者提供企业存储领域高质量的原创内容，及时、全面的资讯、技术、方案以及案例文章，力求成为业界领先的存储媒体。比特存储周刊始终致力于用户的企业信息化建设、存储业务、数据保护与容灾构建以及数据管理部署等方面服务。
比特安全周刊通过专业的信息安全内容建设，为企业级用户打造最具商业价值的信息沟通平台，并为安全厂商提供多层面、多维度的媒体宣传手段。与其他同类网站信息安全内容相比，比特安全周刊运作模式更加独立，对信息安全界的动态新闻更新更快。
新闻中心热点推荐
新闻中心以独特视角精选一周内最具影响力的行业重大事件或圈内精彩故事，为企业级用户打造重点突出，可读性强，商业价值高的信息共享平台；同时为互联网、IT业界及通信厂商提供一条精准快捷，渗透力强，覆盖面广的媒体传播途径。
云计算周刊
比特云计算周刊关注云计算产业热点技术应用与趋势发展，全方位报道云计算领域最新动态。为用户与企业架设起沟通交流平台。包括IaaS、PaaS、SaaS各种不同的服务类型以及相关的安全与管理内容介绍。
CIO俱乐部周刊
比特CIO俱乐部周刊以大量高端CIO沙龙或专题研讨会以及对明星CIO的深入采访为依托，汇聚中国500强CIO的集体智慧。旨为中国杰出的CIO提供一个良好的互融互通 、促进交流的平台，并持续提供丰富的资讯和服务，探讨信息化建设，推动中国信息化发展引领CIO未来职业发展。
IT专家新闻邮件长期以来，以定向、分众、整合的商业模式，为企业IT专业人士以及IT系统采购决策者提供高质量的原创内容，包括IT新闻、评论、专家答疑、技巧和白皮书。此外，IT专家网还为读者提供包括咨询、社区、论坛、线下会议、读者沙龙等多种服务。
X周刊是一份IT人的技术娱乐周刊，给用户实时传递I最新T资讯、IT段子、技术技巧、畅销书籍，同时用户还能参与我们推荐的互动游戏，给广大的IT技术人士忙碌工作之余带来轻松休闲一刻。
微信扫一扫
关注Chinabyte最近一直在做有关内存方面的优化工作，在做优化的过程，除了关注内存的申请量以及GC的情况之外，我们经常需要想方法找出是那些对象占用了大量内存，以及他们是如何导致GC的，这意味着我们需要获取对象申请的信息（大小，类型，堆栈等），我们这篇文章来介绍下几种获取对象申请信息的方法
Allocation Trakcer
Allocation Tracker是android studio自带的一个功能，我们可以在MemoryMonitor中打开使用：
如上图，点击红框按钮，然后操作app，开始allocation tracking，当认为需要结束的时候，再次点击按钮，稍等片刻，即可以在android studio中dump出在&这段时间&内&新申请&对象的信息：
这种使用方式相当直观，可以看到申请对象大小，数量，还有堆栈等，通过这些信息，我们可以作为我们接下来进行内存优化的参考
但是，对于这种获取申请对象信息的方法，会存在几个问题：
获取的信息过于分散，中间夹杂着不少其他的信息，不完全是app申请的，可能需要进行不少查找才能定位到具体的问题
跟TraceView一样，无法做到自动化分析，每次都需要开发者手工开始/结束，对于某些问题的分析可能会造成不便，而且对于批量分析来说也比较困难
虽然在allocation tracking的时候，不会对手机本身的运行造成过多的性能影响，然而在停止allocation tracker的时候，直到把数据dump出来之前，会把手机完全卡死，时间过长甚至会直接ANR
对于这几个问题，特别是自动化分析来说，是否能够直接在代码上发起allocation tracker的请求并获得数据来分析呢？
在代码中发起allocation tracker请求
自然是可以的，不然为什么会有这个标题。。。
我们可以把Android Studio的源码clone下来，在可以找到对应的git地址。在clone下来之后，我们可以在./tools/adt/idea/android/src/com/android/tools/idea/ddms/actions/ToggleAllocationTrackingAction.java中看到android studio具体是如何发起和停止Allocation Tracker的：
发起和停止：
if (c.getClientData().getAllocationStatus() ==
ClientData.AllocationTrackingStatus.ON) {
c.requestAllocationDetails();
c.enableAllocationTracker(false);
if (myEvent == null) {
// Unexpected end of tracking, start now:
myEvent = myEvents.start(now, MemoryMonitorView.EVENT_ALLOC);
myEvent.stop(now);
myEvent = null;
installListener(c, myProject);
c.enableAllocationTracker(true);
if (myEvent != null) {
// TODO add support for different end types (error, etc)
myEvent.stop(now);
myEvent = myEvents.start(now, MemoryMonitorView.EVENT_ALLOC);
c.requestAllocationStatus();
获取并解析数据：
AndroidDebugBridge.addClientChangeListener(new IClientChangeListener() {
public void clientChanged(Client client, int changeMask) {
if (client == listeningClient && (changeMask & Client.CHANGE_HEAP_ALLOCATIONS) != 0) {
final byte[] data = client.getClientData().getAllocationsData();
ApplicationManager.getApplication().invokeLater(new Runnable() {
public void run() {
if (myProject.isDisposed()) {
final CaptureService service = CaptureService.getInstance(myProject);
String name = service.getSuggestedName(listeningClient);
CaptureHandle handle = service.startCaptureFile(AllocationCaptureType.class, name);
service.appendDataCopy(handle, data);
// Remove self from listeners.
AndroidDebugBridge.removeClientChangeListener(this);
可以看出来这应该是一个异步的过程，在发起请求之后，系统会开始记录，然后再次发起停止请求之后，请求获得内存申请的数据（通过c.requestAllocationDetails这一行），然后再预先注册好的IClientChangeListener回调当中，获得数据已经准备好的通知，然后再获取数据，进行分析
对于这里发起和停止Allocation的数据，以及注册的回调，大概涉及到了Client，AndroidDebugBridge，IClientChangeListener等几个接口，这几个接口均不是Android Studio/IDEA中自带的类，而是在ddmlib这个库中包含的，在android studio源码/tools/base/ddmlib目录中有其源码，另外，在/prebuilts/tools/common/offline-m2/com/android/tools/ddms/ddmlib目录中也有其预先build好的jar包。
ddmlib这个库的作用，是用来建立电脑和android手机上连接的AndroidDebugBridge，然后让其对手机发起一些请求，例如刚才的AllocationTracker，还有dump hprof，traceview，甚至可以直接发送JdwpPacket，自定义PC和手机上的通讯（当然这个接口并非是开放的）。
更重要的是，Google这个库是对外开放的，并且放到了maven当中，可以让开发者直接获取到这个库，不过似乎Google并没有大肆宣传这个，甚至连文档都没有。
既然如此，我们也可以仿照上面的代码，用代码发起一次AllocationTracker请求，并进行分析：
AndroidDebugBridge.init(true);
AndroidDebugBridge bridge = AndroidDebugBridge.createBridge("/path/to/your/adb/command", false);
while (!bridge.isConnected() && !bridge.hasInitialDeviceList()) {
Thread.sleep(200);
catch (Exception e) {
System.out.println(e);
if (bridge.getDevices() != null && bridge.getDevices().length & 0) {
IDevice device = bridge.getDevices()[0];
final Client client = device.getClient("com.example.ragnarok.allocrecordtest");
System.out.print("client: " + client);
if (client == null) {
AndroidDebugBridge.addClientChangeListener(new AndroidDebugBridge.IClientChangeListener() {
public void clientChanged(Client cl, int changeMask) {
if (cl == client) {
if ((changeMask & Client.CHANGE_HEAP_ALLOCATIONS) != 0) {
System.out.println("clientChanged: " + cl + ", " + changeMask);
byte[] data = cl.getClientData().getAllocationsData();
if (data != null) {
AllocationInfo[] infoList = AllocationsParser.parse(ByteBuffer.wrap(data));
client.enableAllocationTracker(true);
new Timer().schedule(new TimerTask() {
public void run() {
client.requestAllocationDetails();
client.enableAllocationTracker(false);
代码比较长，我们主要做了这些操作：
初始化AndroidDebugBridge，并获取连接上的第一个设备对应的IDevice
获取这个设备上"com.example.ragnarok.allocrecordtest"这个进程上对应的Client实例
注册回调，并在回调中获取AllocationTracker回来的数据，并调用AllocationParser进行解析
发起和停止allocation tracker
最后在分析的时候，我们获得了一组AllocationInfo，存储了申请对象的信息：
public class AllocationInfo {
private final String mAllocatedClass;
private final int mAllocNumber;
private final int mAllocationSize;
private final short mThreadId;
private final StackTraceElement[] mStackTrace;
因为现在可以用代码发起Allocation Tracker请求了，那我们就可以接入自动化分析，并过滤掉我们不需要的数据。
但是这样，也还是会有问题：
这种方法会占用adb端口，这意味着可能在使用的时候，需要停止掉其他地方对adb的使用
在停止allocation tracker之后，requestAllocationDetails的调用还是会卡死手机，当然其实对于自动化分析来说，这里问题应该不大，但是对于使用者来说，还是造成了些许不爽
对于上面的第二个问题，我们先来分析下android上的JVM是如何响应发过来的allocation tracker请求的
Android的JVM如何响应allocation tracker请求（Dalvik only now）
我们先来看下Dalvik虚拟机是怎么响应这个请求的，下面仅以4.4.4的代码为例
首先，Dalvik虚拟机在收到Allocation Tracker的请求之后，在对JdwpPacket包进行解析之后，最后会在DdmVmInternal这个类中进行处理，这个类在/libcore/dalvik/src/main/java/org/apache/harmony/dalvik/ddmc/DdmVmInternal.java当中，其中有这么两个方法：
* Enable or disable "recent allocation" tracking.
native public static void enableRecentAllocations(boolean enable);
* Return a boolean indicating whether or not the "recent allocation"
* feature is currently enabled.
native public static boolean getRecentAllocationStatus();
很明显，这两个方法是用于开启和关闭Allocation Tracker，并且获得申请对象信息的数据的，然而是native的方法，对应的native代码在/dalvik/vm/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cpp这里：
* public static void enableRecentAllocations(boolean enable)
* Enable or disable recent allocation tracking.
static void Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_enableRecentAllocations(
const u4* args, JValue* pResult)
bool enable = (args[0] != 0);
if (enable)
(void) dvmEnableAllocTracker();
(void) dvmDisableAllocTracker();
RETURN_VOID();
* public static byte[] getRecentAllocations()
* Fill a buffer with data on recent heap allocations.
static void Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocations(
const u4* args, JValue* pResult)
ArrayObject* data;
data = dvmDdmGetRecentAllocations();
dvmReleaseTrackedAlloc((Object*) data, NULL);
RETURN_PTR(data);
而dvmEnableAllocTracker，dvmDisableAllocTracker，dvmDdmGetRecentAllocations这几个方法，经过几层的调用之后，最后是调用到了/dalvik/vm/AllocTracker.cpp这里的方法：
* Enable allocation tracking.
Does nothing if tracking is already enabled.
* Returns "true" on success.
bool dvmEnableAllocTracker()
bool result = true;
dvmLockMutex(&gDvm.allocTrackerLock);
if (gDvm.allocRecords == NULL) {
gDvm.allocRecordMax = getAllocRecordMax();
ALOGI("Enabling alloc tracker (%d entries, %d frames --& %d bytes)",
gDvm.allocRecordMax, kMaxAllocRecordStackDepth,
sizeof(AllocRecord) * gDvm.allocRecordMax);
gDvm.allocRecordHead = gDvm.allocRecordCount = 0;
gDvm.allocRecords = (AllocRecord*) malloc(sizeof(AllocRecord) * gDvm.allocRecordMax);
if (gDvm.allocRecords == NULL)
result = false;
dvmUnlockMutex(&gDvm.allocTrackerLock);
return result;
* Disable allocation tracking.
Does nothing if tracking is not enabled.
void dvmDisableAllocTracker()
dvmLockMutex(&gDvm.allocTrackerLock);
if (gDvm.allocRecords != NULL) {
free(gDvm.allocRecords);
gDvm.allocRecords = NULL;
dvmUnlockMutex(&gDvm.allocTrackerLock);
* Generate a DDM packet with all of the tracked allocation data.
* On success, returns "true" with "*pData" and "*pDataLen" set.
bool dvmGenerateTrackedAllocationReport(u1** pData, size_t* pDataLen)
{ .... } // 这个方法用于dump出gDvm.allocRecords中的数据
从上面的代码可以看出，在开启了Allocation Tracker之后，在Dalvik全局变量gDvm下，将其中的allocRecords指向了一块新的申请的内存区域，另外allocRecordHead指向最新申请的对象信息的index，allocRecordCount则是总的记录的数量，另外allocRecordMax则是整个Allocation Tracker所允许记录的最大申请对象信息的数目，在4.4.4这个版本下，这个值默认是65536，也可以在手机中的/sytem/build.prop中指定dalvik.vm.allocTrackerMax项的值。
这里很明显看出来，gDvm.allocRecords是用来记录新申请对象的信息的，而申请对象的时候，只要开启了Allocation Tracker，每次都会往这里添加一个记录，具体代码在这里：
首先这里是新申请对象地方，在/dalvik/vm/alloc/Alloc.cpp中：
* Create an instance of the specified class.
* Returns NULL and throws an exception on failure.
Object* dvmAllocObject(ClassObject* clazz, int flags)
Object* newObj;
/* allocate on GC memory is zeroed out */
newObj = (Object*)dvmMalloc(clazz-&objectSize, flags);
if (newObj != NULL) {
DVM_OBJECT_INIT(newObj, clazz);
dvmTrackAllocation(clazz, clazz-&objectSize);
/* notify DDMS */
return newObj;
而在dvmTrackAllocation方法，则是在/vm/AllocTracker.h中定义：
* If allocation tracking is enabled, add a new entry to the set.
#define dvmTrackAllocation(_clazz, _size)
if (gDvm.allocRecords != NULL)
dvmDoTrackAllocation(_clazz, _size);
void dvmDoTrackAllocation(ClassObject* clazz, size_t size);
// dvmDoTrackAllocation的定义在/dalvik/vm/AllocTracker.cpp当中
* Add a new allocation to the set.
void dvmDoTrackAllocation(ClassObject* clazz, size_t size)
Thread* self = dvmThreadSelf();
if (self == NULL) {
ALOGW("alloc tracker: no thread");
dvmLockMutex(&gDvm.allocTrackerLock);
if (gDvm.allocRecords == NULL) {
dvmUnlockMutex(&gDvm.allocTrackerLock);
/* advance and clip */
if (++gDvm.allocRecordHead == gDvm.allocRecordMax)
gDvm.allocRecordHead = 0;
AllocRecord* pRec = &gDvm.allocRecords[gDvm.allocRecordHead];
pRec-&clazz = clazz;
pRec-&size = size;
pRec-&threadId = self-&threadId;
getStackFrames(self, pRec);
if (gDvm.allocRecordCount & gDvm.allocRecordMax)
gDvm.allocRecordCount++;
dvmUnlockMutex(&gDvm.allocTrackerLock);
分析到这里，Dalvik对Allocation Tracker的响应过程就非常清晰了：
在收到Allocation Tracker的请求的时候，首先给Dalvik全局变量gDvm中的allocRecords字段指向一段新申请的内存，申请内存的大小，由gDvm.allocRecordMax指定
后续Dalvik每次新申请对象的时候，只要allocRecords不为NULL，那就会不断的往allocRecords指向的内存区域中写入的新申请对象的信息，包括类型，大小，线程号，堆栈
而gDvm这个变量则具体是一个全局记录Dalvik虚拟机中状态的全局变量，定义和声明都在/dalvik/vm/Globals.h中：
struct DvmGlobals {
* Used for tracking allocations that we report to DDMS.
When the feature
* is enabled (through a DDMS request) the "allocRecords" pointer becomes
* non-NULL.
pthread_mutex_t allocTrackerLock;
AllocRecord*
allocRecords;
allocRecordHead;
/* most-recently-added entry */
allocRecordCount;
/* #of valid entries */
allocRecordMax;
/* Number of allocated entries. */
extern struct DvmGlobals gDvm;
而AllocRecord的定义，则是在/dalvik/vm/AllocTracker.cpp&中：
* Record the details of an allocation.
struct AllocRecord {
ClassObject*
/* class allocated in this block */
/* total size requested */
/* simple thread ID; could be recycled */
unused entries have method==NULL */
const Method* method;
/* which method we're executing in */
/* current execution offset, in 16-bit units */
} stackElem[kMaxAllocRecordStackDepth];
#define kMaxAllocRecordStackDepth
/* max 255 */
可以看出来这里拿到的信息，跟直接使用ddmlib的是一样的
另外，可以看到gDvm的声明是为extern的，这意味着我们或许可以&直接&获取到这个变量，一颗赛艇！
不影响手机本身性能的情况下获取申请对象信息
从上面的代码分析可以看到，类型为DvmGlobals的gDvm这个变量被声明成了extern，并且为非static变量，这意味在dalvik的so中，我们可以直接在符号表中获取到这个变量，简单来说，测试的代码如下：
#include "Globals.h"
void * handle = dlopen("libdvm.so", RTLD_NOW);
snprintf(buff, 1024, "handle is 0x%x", handle);
LOGI("%s", buff);
t_gDvm = (struct DvmGlobals *)dlsym(handle, "gDvm");
if (t_gDvm) {
LOGI("get DvmGlobals");
// now t_gDvm-&allocRecords is the allocation record data
上面的#include "Globals.h"是指Dalvik源码中的Globals.h头文件， 另外这段Native的代码需要打包在某个app当中，然后在开启Allocation Tracker之后（之前介绍的随便一种方法都可以），运行这段代码，那么t_gDvm-&allocRecords中就是申请对象的数据了，可以直接读取里面的字段，打印出来大概是这样的：
由于是直接读取Dalvik本身记录对象信息的结构，没有了结束Allocation Tracker时候把数据dump出来的请求，这意味着完全不会影响手机本身的性能，而且对于对象信息的获取，也能够更加的及时，例如说每隔10s把数据拿出来分析。相对来说，对于之前使用ddmlib的方案，10s定时请求这么高的频率，很有可能跑一会直接就把手机卡死了。
但是对于这种方案，会存在兼容性问题，这里可以看到，我们获取gDvm变量的方式是用dlsym系统调用直接拿出来，然后强转成DvmGlobals类型，然而由于不同版本的Dalvik虚拟机中的DvmGlobals的定义不一样，可能会造成拿出gDvm这个符号之后，对应的allocRecords字段并不是真正的在这台机器上的allocRecords字段，出现数据的错乱，或者gDvm-&allocRecords压根为NULL 。就目前的简单测试来，暂时只有MX3 4.4.4系统的flyme os能够正常操作，估计这里要适配大部分机器的话，工作量应该不少。
关于Allocation Tracker在JVM层的响应，目前暂时只有Dalvik的分析，而ART对Allocation Tracker的处理似乎更加复杂，尚在研究中
这篇文章中的示例代码，可以从拿到
阅读(...) 评论()
