怎样用Java获取内存中的数据

可以考虑使用内存映射文件：javanioMappedByteBuffer，主要适合放入较大的数据进入系统内存

可以考虑使用：javanioByteBufferallocateDirect()方法进行分配，可以将一些不适合放入堆里的数据放入系统内存

还可以采用java本地调用的方式，实现对系统自身内存的掌控与调度，这种方式可以让你灵活的访问系统的内存。

java的堆放入的对象尺度是有限制的，这里建议参考BigMemory 的实现机制以及内存管理机制

如果自己管理内存的话，建议参考其他语言对内存管理的方式。

你可以把数据放入线性数据结构中（这些数据是在系统内存中，而非jvm管理的内存里），这样就不存在分代问题，可以由你的应用在适当的时候清理系统的内存。这样，你的内存模型-释放机制就与jvm的内存管理机制处于一个互不干扰的异行线上。

应用里添加 SystemManagement

文件前加上

Imports SystemManagement     ''' <summary>

    ''' 获取系统内存大小

    ''' </summary>

    ''' <returns>内存大小（单位Byte）</returns>

    Private shared Function GetPhisicalMemory()As Long

        dim searcher = new ManagementObjectSearcher()   '用于查询一些如系统信息的管理对象

        searcherQuery = new SelectQuery("Win32_PhysicalMemory ", "", new string() { "Capacity" })'设置查询条件 

        dim collection = searcherGet()   '获取内存容量 

            dim em = collectionGetEnumerator()

            

            dim capacity as long= 0

            While (emMoveNext())

                dim baseObj = emCurrent

                If (baseObjProperties("Capacity")Value IsNot Nothing) Then                    

                    Try

                        capacity += longParse(baseObjProperties("Capacity")ValueToString())

                    Catch

                        return 0

                    End Try

                End If 

                

            End While

            return capacity

        End Function

首先是获取特定进程对象，可以使用ProcessGetProcesses()方法来获取系统中运行的所有进程，或者使用ProcessGetCurrentProcess()方法来获取当前程序所对应的进程对象。当有了进程对象后，可以通过进程对象名称来创建PerformanceCounter类型对象，通过设定PerformanceCounter构造函数的参数实现获取特定进程的CPU和内存使用情况。

具体实例代码如下：

首先是获取本机中所有进程对象，分别输出某一时刻各个进程的内存使用情况：

using System;using SystemCollectionsGeneric;using SystemLinq;using SystemText;using SystemDiagnostics;using SystemThreading;namespace CSharpPerformance{//该程序可以实时监控所有进程或者指定进程的工作集、私有工作集 class Program { static void Main(string[] args) { //新建一个Stopwatch变量用来统计程序运行时间 Stopwatch watch = StopwatchStartNew(); //获取本机运行的所有进程ID和进程名,并输出哥进程所使用的工作集和私有工作集 foreach (Process ps in ProcessGetProcesses()) { PerformanceCounter pf1 = new PerformanceCounter("Process", "Working Set - Private", psProcessName); PerformanceCounter pf2 = new PerformanceCounter("Process", "Working Set", psProcessName); ConsoleWriteLine("{0}:{1} {2:N}KB", psProcessName, "工作集(进程类)", psWorkingSet64 / 1024); ConsoleWriteLine("{0}:{1} {2:N}KB", psProcessName, "工作集 ", pf2NextValue() / 1024); //私有工作集 ConsoleWriteLine("{0}:{1} {2:N}KB", psProcessName, "私有工作集 ", pf1NextValue() / 1024); } watchStop(); ConsoleWriteLine(watchElapsed); ConsoleReadLine(); } }}

其中，工作集psWorkingSet64是静态的，pf2NextValue()是动态变化的，工作集包含进程运行时其独占的内存和与其他进程共享的内存的和，而私有工作集是只包含进程独占的内存。

下面一组代码可以动态显示本程序所对应的进程的CPU和内存使用率的变化：

首先是SystemInfocs类：

using System;using SystemCollectionsGeneric;using SystemDiagnostics;using SystemThreading;using SystemIO;using SystemText;using SystemManagement;using SystemRuntimeInteropServices;namespace CSharpPerformance{ public class SystemInfo { private int m_ProcessorCount = 0; //CPU个数 private PerformanceCounter pcCpuLoad; //CPU计数器 private long m_PhysicalMemory = 0; //物理内存 private const int GW_HWNDFIRST = 0; private const int GW_HWNDNEXT = 2; private const int GWL_STYLE = (-16); private const int WS_VISIBLE = 268435456; private const int WS_BORDER = 8388608; #region AIP声明 [DllImport("IpHlpApidll")] extern static public uint GetIfTable(byte[] pIfTable, ref uint pdwSize, bool bOrder); [DllImport("User32")] private extern static int GetWindow(int hWnd, int wCmd); [DllImport("User32")] private extern static int GetWindowLongA(int hWnd, int wIndx); [DllImport("user32dll")] private static extern bool GetWindowText(int hWnd, StringBuilder title, int maxBufSize); [DllImport("user32", CharSet = CharSetAuto)] private extern static int GetWindowTextLength(IntPtr hWnd); #endregion #region 构造函数 ///

/// 构造函数，初始化计数器等 ///

public SystemInfo() { //初始化CPU计数器 pcCpuLoad = new PerformanceCounter("Processor", "% Processor Time", "_Total"); pcCpuLoadMachineName = ""; pcCpuLoadNextValue(); //CPU个数 m_ProcessorCount = EnvironmentProcessorCount; //获得物理内存 ManagementClass mc = new ManagementClass("Win32_ComputerSystem"); ManagementObjectCollection moc = mcGetInstances(); foreach (ManagementObject mo in moc) { if (mo["TotalPhysicalMemory"] != null) { m_PhysicalMemory = longParse(mo["TotalPhysicalMemory"]ToString()); } } } #endregion #region CPU个数 ///

/// 获取CPU个数 ///

public int ProcessorCount { get { return m_ProcessorCount; } } #endregion #region CPU占用率 ///

/// 获取CPU占用率 ///

public float CpuLoad { get { return pcCpuLoadNextValue(); } } #endregion #region 可用内存 ///

/// 获取可用内存 ///

public long MemoryAvailable { get { long availablebytes = 0; //ManagementObjectSearcher mos = new ManagementObjectSearcher("SELECT FROM Win32_PerfRawData_PerfOS_Memory"); //foreach (ManagementObject mo in mosGet()) //{ // availablebytes = longParse(mo["Availablebytes"]ToString()); //} ManagementClass mos = new ManagementClass("Win32_OperatingSystem"); foreach (ManagementObject mo in mosGetInstances()) { if (mo["FreePhysicalMemory"] != null) { availablebytes = 1024 longParse(mo["FreePhysicalMemory"]ToString()); } } return availablebytes; } } #endregion #region 物理内存 ///

/// 获取物理内存 ///

public long PhysicalMemory { get { return m_PhysicalMemory; } } #endregion #region 结束指定进程 ///

/// 结束指定进程 ///

///

进程的 Process IDpublic static void EndProcess(int pid) { try { Process process = ProcessGetProcessById(pid); processKill(); } catch { } } #endregion #region 查找所有应用程序标题 ///

/// 查找所有应用程序标题 ///

///

应用程序标题范型

public static List

FindAllApps(int Handle) { ListApps = new List(); int hwCurr; hwCurr = GetWindow(Handle, GW_HWNDFIRST); while (hwCurr > 0) { int IsTask = (WS_VISIBLE | WS_BORDER); int lngStyle = GetWindowLongA(hwCurr, GWL_STYLE); bool TaskWindow = ((lngStyle & IsTask) == IsTask); if (TaskWindow) { int length = GetWindowTextLength(new IntPtr(hwCurr)); StringBuilder sb = new StringBuilder(2 length + 1); GetWindowText(hwCurr, sb, sbCapacity); string strTitle = sbToString(); if (!stringIsNullOrEmpty(strTitle)) { AppsAdd(strTitle); } } hwCurr = GetWindow(hwCurr, GW_HWNDNEXT); } return Apps; } #endregion }}

然后是执行代码：

using System;using SystemCollectionsGeneric;using SystemLinq;using SystemText;using SystemDiagnostics;using SystemThreading;namespace CSharpPerformance{//该程序可以实时监控程序本身对应进程的工作集、私有工作集和CPU使用率 class Program { static void Main(string[] args) { //获取当前进程对象 Process cur = ProcessGetCurrentProcess(); PerformanceCounter curpcp = new PerformanceCounter("Process", "Working Set - Private", curProcessName); PerformanceCounter curpc = new PerformanceCounter("Process", "Working Set", curProcessName); PerformanceCounter curtime = new PerformanceCounter("Process", "% Processor Time", curProcessName); //上次记录CPU的时间 TimeSpan prevCpuTime = TimeSpanZero; //Sleep的时间间隔 int interval = 1000; PerformanceCounter totalcpu = new PerformanceCounter("Processor", "% Processor Time", "_Total"); SystemInfo sys = new SystemInfo(); const int KB_DIV = 1024; const int MB_DIV = 1024 1024; const int GB_DIV = 1024 1024 1024; while (true) { //第一种方法计算CPU使用率 //当前时间 TimeSpan curCpuTime = curTotalProcessorTime; //计算 double value = (curCpuTime - prevCpuTime)TotalMilliseconds / interval / EnvironmentProcessorCount 100; prevCpuTime = curCpuTime; ConsoleWriteLine("{0}:{1} {2:N}KB CPU使用率：{3}", curProcessName, "工作集(进程类)", curWorkingSet64 / 1024,value);//这个工作集只是在一开始初始化，后期不变 ConsoleWriteLine("{0}:{1} {2:N}KB CPU使用率：{3}", curProcessName, "工作集 ", curpcNextValue() / 1024,value);//这个工作集是动态更新的 //第二种计算CPU使用率的方法 ConsoleWriteLine("{0}:{1} {2:N}KB CPU使用率：{3}%", curProcessName, "私有工作集 ", curpcpNextValue() / 1024,curtimeNextValue()/EnvironmentProcessorCount); //ThreadSleep(interval); //第一种方法获取系统CPU使用情况 ConsoleWrite("r系统CPU使用率：{0}%", totalcpuNextValue()); //ThreadSleep(interval); //第二章方法获取系统CPU和内存使用情况 ConsoleWrite("r系统CPU使用率：{0}%，系统内存使用大小：{1}MB({2}GB)", sysCpuLoad, (sysPhysicalMemory - sysMemoryAvailable) / MB_DIV, (sysPhysicalMemory - sysMemoryAvailable) / (double)GB_DIV); ThreadSleep(interval); } ConsoleReadLine(); } }}

以上程序可以正常运行，没隔1S刷新一次，实现动态显示本程序对应进程的CPU和内存使用情况。

首先要明确windows 的内存管理方式, （在 windows XP 非 3GB enabled）。 ring3程序也就是用户空间的进程可以用的空间地址是 virtual address 0x00000000 - 0x7FFFFFFF ,注意virual address 呵呵，而 0x80000000 以后为内核使用 都是 virtual address啊。ring3 进程不能读取 0x80000000 以后的地址。0x0000000 - 0x7FFFFFFF 也并不是都可以读取的。这个空间中会根据系统需要由系统分配一定的 region 或一系列的 regions。只有位于这些 regions 的地址是可以被ring3 进程读取的。所以比如任意地址 如 0x100 若这个地址不再任何一个 region 当中。就会出错（指定地址无内存）。实际上即是说，系统没有为 0x100 这个地址建立页表映射，也就不可读。 若你所说想要实现读取内核地址空间，也只能读取已经建立了页表映射的地址。不然同样要出错。若想要判断一个地址是否是有效的，如你所担心的，用户可能传给你一个非法地址。可以用一些api 判断合法性。如 VirtualQuery 更强大的还有VirtualQueryEx。 >

public class CpuInfoCollector

{

[DllImport("kernel32")]

//获取系统内存信息

private static extern void GlobalMemoryStatus(ref MemoryInfor meminfo);

private const string CategoryName = "Processor";

private const string CounterName = "% Processor Time";

private const string InstanceName = "_Total"; //最大内存使用

private float m_MaxMemory=0;

//最大内存使用时间

private DateTime m_MaxMemoryTime=DateTimeNow;

//最小内存使用

private float m_MinMemory;

//最小内存使用时间

private DateTime m_MinMemoryTime = DateTimeNow; //最大Cpu使用

private float m_MaxCpu=0;

//最大Cpu使用时间

private DateTime m_MaxCpuTime = DateTimeNow;

//最小Cpu使用

private float m_MinCpu;

//最小Cpu使用时间

private DateTime m_MinCpuTime = DateTimeNow; /// <summary>

/// 机器性能类(获取CPU使用率)

/// </summary>

private static PerformanceCounter pc;

public DTServerInfoCollector()

{

pc = new PerformanceCounter(CategoryName, CounterName, InstanceName);

}

/// <summary>

/// 获取进程名称

/// </summary>

private static string m_ProcessName = SystemReflectionAssemblyGetExecutingAssembly()GetName()Name;

/// 获取CPU占用率

public float CpuLoad

{

get

{

//实时cpu信息

float cpu = pcNextValue();

if (cpu>MaxCpu)

{

//最大cpu使用赋值

MaxCpu = cpu;

//最大cpu使用时间

MaxCpuTime = DateTimeNow;

}

if (cpu < MinCpu)

{

//最小cpu使用赋值

MinCpu = cpu;

//最小cpu使用时间

MinCpuTime = DateTimeNow;

}

ThreadSleep(500);

return pcNextValue();

}

} //最大内存使用

public float MaxMemory

{

get { return m_MaxMemory; }

set { m_MaxMemory = value; }

} //最大内存使用时间

public DateTime MaxMemoryTime

{

get { return m_MaxMemoryTime; }

set { m_MaxMemoryTime = value; }

}

//最小内存使用

public float MinMemory

{

get { return m_MinMemory; }

set { m_MinMemory = value; }

}

//最小内存使用时间

public DateTime MinMemoryTime

{

get { return m_MinMemoryTime; }

set { m_MinMemoryTime = value; }

}

//最大Cpu使用

public float MaxCpu

{

get { return m_MaxCpu; }

set { m_MaxCpu = value; }

} //最大Cpu使用时间

public DateTime MaxCpuTime

{

get { return m_MaxCpuTime; }

set { m_MaxCpuTime = value; }

}

//最小Cpu使用

public float MinCpu

{

get { return m_MinCpu; }

set { m_MinCpu = value; }

}

//最小Cpu使用时间

public DateTime MinCpuTime

{

get { return m_MinCpuTime; }

set { m_MinCpuTime = value; }

}

/// 获取内存使用

private MemoryInfo GetMemoryInfo()

{

MemoryInfo mInfo = new MemoryInfo();

try

{

MemoryInfor memInfor = GetMemoryInfor();

long lMemoryTotalMB = memInfordwTotalPhys/1024/1024;

long lMemoryAvailMB = memInfordwAvailPhys/1024/1024;

//已经使用内存=最大内存-剩余内存

long lMemoryUsedMB = lMemoryTotalMB - lMemoryAvailMB;

//最大内存

mInfoMemory = lMemoryTotalMB;

if (lMemoryUsedMB>MaxMemory)

{

MaxMemory = lMemoryUsedMB;

MaxMemoryTime = DateTimeNow;

}

if (lMemoryUsedMB < MinMemory)

{

MinMemory = lMemoryUsedMB;

MinMemoryTime = DateTimeNow;

}

//已经使用内存

mInfoMemoryUsed = lMemoryUsedMB;

//最大使用内存

mInfoMaxMemory = MaxMemory;

//最大内存的时间

mInfoMaxMemoryTime = MaxMemoryTime;

//最小使用内存

mInfoMinMemory = MinMemory;

//最小内存的时间

mInfoMinMemoryTime = MinMemoryTime; }

catch (Exception ex)

{

return null;

}

return mInfo; }

/// <summary>

/// 获取系统内存信息

/// </summary>

private MemoryInfor GetMemoryInfor()

{

MemoryInfor memoryInfo = new MemoryInfor();

GlobalMemoryStatus(ref memoryInfo);

return memoryInfo;

}

/// <summary>

/// 获取程序的线程数

/// </summary>

public static int Threads

{

get

{

int i = 0;

try

{

foreach (Process vProcess in ProcessGetProcesses())

{

if (vProcessProcessName == m_ProcessName)

{

i = vProcessThreadsCount;

break;

}

}

}

catch (Exception ex)

{

}

return i;

}

}

}

/// <summary>

/// 定义内存的信息结构

/// </summary>

[StructLayout(LayoutKindSequential)]

public struct MemoryInfor

{

public uint dwLength;

/// <summary>

/// 已经使用的内存

/// </summary>

public uint dwMemoryLoad;

/// <summary>

/// 总物理内存大小

/// </summary>

public uint dwTotalPhys;

/// <summary>

/// 可用物理内存大小

/// </summary>

public uint dwAvailPhys;

/// <summary>

/// 交换文件总大小

/// </summary>

public uint dwTotalPageFile;

/// <summary>

/// 可用交换文件大小

/// </summary>

public uint dwAvailPageFile;

/// <summary>

/// 总虚拟内存大小

/// </summary>

public uint dwTotalVirtual;

/// <summary>

/// 可用虚拟内存大小

/// </summary>

public uint dwAvailVirtual;

}

using System;

using SystemCollectionsGeneric;

using SystemComponentModel;

using SystemData;

using SystemDrawing;

using SystemText;

using SystemWindowsForms;

using SystemRuntimeInteropServices;

//加入这个命名空间,用于调用系统的DLL

namespace WindowsApplication2

{

public partial class Form1 : Form

{

public struct MEMORYSTATUS1 //这个结构用于获得系统信息

{

internal uint dwLength;

internal uint dwMemoryLoad;

internal uint dwTotalPhys;

internal uint dwAvailPhys;

internal uint dwTotalPageFile;

internal uint dwAvailPageFile;

internal uint dwTotalVirtual;

internal uint dwAvailVirtual;

}

[DllImport("kernel32dll ")]//调用系统DLL

public static extern void GlobalMemoryStatus(ref MEMORYSTATUS1 lpBuffer); //获得系统DLL里的函数

public Form1()

{

InitializeComponent();

}

private void button5_Click(object sender, EventArgs e)//这个是触发事件的按纽

{

MEMORYSTATUS1 vBuffer = new MEMORYSTATUS1();//实例化结构

GlobalMemoryStatus(ref vBuffer);//给此结构赋值

string useinfo=ConvertToString(vBufferdwAvailPhys);//获得已用内存量

string allinfo=ConvertToString(vBufferdwTotalPhys);//获得内存总量

MessageBoxShow(useinfo + ":" + allinfo);

//显示已用内存量:总内存量

}

}

}

以上就是关于怎样用Java获取内存中的数据全部的内容，包括:怎样用Java获取内存中的数据、vb.net获取内存总量、C#获取特定进程CPU和内存使用率等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！