java的內存使用
❶ 一個java對象到底佔用多大內存
Object o=new Object():
在java中空對象佔八個位元組，對象的引用佔四個位元組。所以上面那條語句所佔的空間是4byte+8byte=12byte.java中的內存是以8的倍數來分配的，所以分配的內存是16byte.
舉個例子：
Class O{
int i;
byte j;
String s;
}
其所佔內存的大小是空對象（8）+int(4)+byte(1)+String引用(4)=17byte,因要是8的整數倍，所以其佔大小為24byte.
當然，如果類里有其他對象的話，也要把其他對象的空間算進去
❷ 如何計算一個Java程序運行佔用多少內存
可以用 system(命令) 調用 DOS/Windows 命令 獲取 正在使用多少 內存 （memory).
命令例子：
wmic process where name="cmd.exe" get WorkingSetSize
這里 "cmd.exe" 你可替換成 你的程序 名字。
你也可以用你的程序 進程 PID 號數 調用， 命令是：
wmic process where processid=6884 get WorkingSetSize
這里6884你可替換成 你的程序 進程 PID。
輸出有2行，第二行是佔用內存位元組數：
WorkingSetSize
4616192
c/c++ 語言 ：
system("wmic process where processid=6884 get WorkingSetSize");
system("wmic process where name=\"cmd.exe\" get WorkingSetSize");
用程序名調用時，若有多個同名程序在運行，輸出的 內存數 將分行輸出出來。
❸ java 在內存中占幾個位元組
不同的數據類型占的內存大小不同 比如int 是四個位元組 char是一個位元組 等等
❹ 如何分析java的內存佔用情況
hi：
虛擬機的內存情況查看，使用Runtime類進行。如下：
//虛擬機內存使用量查詢
class RamRun implements Runnable{
private Runtime runtime;
public void run(){
try{
runtime=Runtime.getRuntime();
System.out.println("處理器的數目"+runtime.availableProcessors());
System.out.println("空閑內存量："+runtime.freeMemory()/ 1024L/1024L + "M av");
System.out.println("使用的最大內存量："+runtime.maxMemory()/ 1024L/1024L + "M av");
System.out.println("內存總量："+runtime.totalMemory()/ 1024L/1024L + "M av");
}catch(Exception e){
e.printStackTrace();
}
}
}
❺ 怎麼獲取 Java 程序使用的內存
首先
創建一個Bean用來存貯要得到的信
public class MonitorInfoBean {
/** 可使用內存. */
private long totalMemory;
/** 剩餘內存. */
private long freeMemory;
/** 最大可使用內存. */
private long maxMemory;
/** 操作系統. */
private String osName;
/** 總的物理內存. */
private long totalMemorySize;
/** 剩餘的物理內存. */
private long freePhysicalMemorySize;
/** 已使用的物理內存. */
private long usedMemory;
/** 線程總數. */
private int totalThread;
/** cpu使用率. */
private double cpuRatio;
public long getFreeMemory() {
return freeMemory;
}
public void setFreeMemory(long freeMemory) {
this.freeMemory = freeMemory;
}
public long getFreePhysicalMemorySize() {
return freePhysicalMemorySize;
}
public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {
this.freePhysicalMemorySize = freePhysicalMemorySize;
}
public long getMaxMemory() {
return maxMemory;
}
public void setMaxMemory(long maxMemory) {
this.maxMemory = maxMemory;
}
public String getOsName() {
return osName;
}
public void setOsName(String osName) {
this.osName = osName;
}
public long getTotalMemory() {
return totalMemory;
}
public void setTotalMemory(long totalMemory) {
this.totalMemory = totalMemory;
}
public long getTotalMemorySize() {
return totalMemorySize;
}
public void setTotalMemorySize(long totalMemorySize) {
this.totalMemorySize = totalMemorySize;
}
public int getTotalThread() {
return totalThread;
}
public void setTotalThread(int totalThread) {
this.totalThread = totalThread;
}
public long getUsedMemory() {
return usedMemory;
}
public void setUsedMemory(long usedMemory) {
this.usedMemory = usedMemory;
}
public double getCpuRatio() {
return cpuRatio;
}
public void setCpuRatio(double cpuRatio) {
this.cpuRatio = cpuRatio;
}
}
之後，建立bean的介面
public interface IMonitorService {
public MonitorInfoBean getMonitorInfoBean() throws Exception;
}
然後，就是最關鍵的，得到cpu的利用率，已用內存，可用內存，最大內存等信息。
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import sun.management.ManagementFactory;
import com.sun.management.OperatingSystemMXBean;
import java.io.*;
import java.util.StringTokenizer;
/**
* 獲取系統信息的業務邏輯實現類.
* @author GuoHuang
*/
public class MonitorServiceImpl implements IMonitorService {
private static final int CPUTIME = 30;
private static final int PERCENT = 100;
private static final int FAULTLENGTH = 10;
private static final File versionFile = new File("/proc/version");
private static String linuxVersion = null;
/**
* 獲得當前的監控對象.
* @return 返回構造好的監控對象
* @throws Exception
* @author GuoHuang
*/
public MonitorInfoBean getMonitorInfoBean() throws Exception {
int kb = 1024;
// 可使用內存
long totalMemory = Runtime.getRuntime().totalMemory() / kb;
// 剩餘內存
long freeMemory = Runtime.getRuntime().freeMemory() / kb;
// 最大可使用內存
long maxMemory = Runtime.getRuntime().maxMemory() / kb;
OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory
.getOperatingSystemMXBean();
// 操作系統
String osName = System.getProperty("os.name");
// 總的物理內存
long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;
// 剩餘的物理內存
long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;
// 已使用的物理內存
long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb
.getFreePhysicalMemorySize())
/ kb;
// 獲得線程總數
ThreadGroup parentThread;
for (parentThread = Thread.currentThread().getThreadGroup(); parentThread
.getParent() != null; parentThread = parentThread.getParent())
;
int totalThread = parentThread.activeCount();
double cpuRatio = 0;
if (osName.toLowerCase().startsWith("windows")) {
cpuRatio = this.getCpuRatioForWindows();
}
else {
cpuRatio = this.getCpuRateForLinux();
}
// 構造返回對象
MonitorInfoBean infoBean = new MonitorInfoBean();
infoBean.setFreeMemory(freeMemory);
infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);
infoBean.setMaxMemory(maxMemory);
infoBean.setOsName(osName);
infoBean.setTotalMemory(totalMemory);
infoBean.setTotalMemorySize(totalMemorySize);
infoBean.setTotalThread(totalThread);
infoBean.setUsedMemory(usedMemory);
infoBean.setCpuRatio(cpuRatio);
return infoBean;
}
private static double getCpuRateForLinux(){
InputStream is = null;
InputStreamReader isr = null;
BufferedReader brStat = null;
StringTokenizer tokenStat = null;
try{
System.out.println("Get usage rate of CUP , linux version: "+linuxVersion);
Process process = Runtime.getRuntime().exec("top -b -n 1");
is = process.getInputStream();
isr = new InputStreamReader(is);
brStat = new BufferedReader(isr);
if(linuxVersion.equals("2.4")){
brStat.readLine();
brStat.readLine();
brStat.readLine();
brStat.readLine();
tokenStat = new StringTokenizer(brStat.readLine());
tokenStat.nextToken();
tokenStat.nextToken();
String user = tokenStat.nextToken();
tokenStat.nextToken();
String system = tokenStat.nextToken();
tokenStat.nextToken();
String nice = tokenStat.nextToken();
System.out.println(user+" , "+system+" , "+nice);
user = user.substring(0,user.indexOf("%"));
system = system.substring(0,system.indexOf("%"));
nice = nice.substring(0,nice.indexOf("%"));
float userUsage = new Float(user).floatValue();
float systemUsage = new Float(system).floatValue();
float niceUsage = new Float(nice).floatValue();
return (userUsage+systemUsage+niceUsage)/100;
}else{
brStat.readLine();
brStat.readLine();
tokenStat = new StringTokenizer(brStat.readLine());
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
String cpuUsage = tokenStat.nextToken();
System.out.println("CPU idle : "+cpuUsage);
Float usage = new Float(cpuUsage.substring(0,cpuUsage.indexOf("%")));
return (1-usage.floatValue()/100);
}
} catch(IOException ioe){
System.out.println(ioe.getMessage());
freeResource(is, isr, brStat);
return 1;
} finally{
freeResource(is, isr, brStat);
}
}
❻ 簡述java內存分配與回收策率有什麼用
引言：大多數情況下，對象在新生代Eden區中分配。當Eden區沒有足夠空間進行分配時，虛擬機將發起一次Minor GC。新生代GC(Minor GC)：指發生在新生代的垃圾收集動作，因為Java對象大多都具備朝生夕滅的特性，所以Minor GC非常頻繁，一般回收速度也比較快。老年代GC(Major GC / Full GC)：指發生在老年代的GC，出現了Major GC，經常會伴有至少一次的Minor GC(但非絕對的，在Parallel Scavenge收集器的收集策略里就有直接進行Major GC的策略選擇過程)。Major GC的速度一般會比Minor GC慢10倍以上。
三、總結
可達性分析:以名為“GC根”的對象為起點，從這些節點向下搜索。當一個對象不能連接到“垃圾回收根”時，意味著它是可回收的。
❼ 怎樣用java實現內存動態分配
1、java是如何管理內存的
Java的內存管理就是對象的分配和釋放問題。（兩部分）
分配 ：內存的分配是由程序完成的，程序員需要通過關鍵字new 為每個對象申請內存空間 (基本類型除外)，所有的對象都在堆 (Heap)中分配空間。
釋放 ：對象的釋放是由垃圾回收機制決定和執行的，這樣做確實簡化了程序員的工作。但同時，它也加重了JVM的工作。因為，GC為了能夠正確釋放對象，GC必須監控每一個對象的運行狀態，包括對象的申請、引用、被引用、賦值等，GC都需要進行監控。
2、 JVM的內存區域組成
java把內存分兩種：一種是棧內存，另一種是堆內存1。在函數中定義的基本類型變數和對象的引用變數都在函數的棧內存中分配；2。堆內存用來存放由new創建的對象和數組以及對象的實例變數 在函數（代碼塊）中定義一個變數時，java就在棧中為這個變數分配內存空間，當超過變數的作用域後，java會自動釋放掉為該變數所分配的內存空間；在堆中分配的內存由java虛擬機的自動垃圾回收器來管理
堆和棧的優缺點
堆的優勢是可以動態分配內存大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配內存的。
缺點就是要在運行時動態分配內存，存取速度較慢； 棧的優勢是，存取速度比堆要快，僅次於直接位於CPU中的寄存器。
另外，棧數據可以共享。但缺點是，存在棧中的數據大小與生存期必須是確定的，缺乏靈活性。
❽ 為什麼java使用的內存比c/c++多那麼多
Java在啟動時就會把用到的內存向操作系統一起申請完。在執行過程中不再需要向操作系統要內存。內存的管理全部由JVM來做。
C++則不一樣，它是用的時候就申請內存，不用了就釋放內存。
其實這個是歷史造成的。
C/C++出現時， 內存很金貴，省著用， 甚至一個位元組，一位一位的摳。
java出現的時候， 硬體不算瓶頸了， 對內存就沒那麼苛刻了。
❾ 怎麼給java分配內存
方法如下： 1、打開eclipse配置文件eclipse.ini，更改把-Xmx（其數值代表jvm可以使用的最大內存數） 2、運行java程序時，選擇run->run configuration->arguments,輸入-Xms100M -Xmx800M（-Xms代表jvm啟動時分配的內存大小，-Xmx代表可最大分配
❿ java中內存的概念 java中環境變數的設置
java把內存劃分成兩種：一種是棧內存，一種是堆內存。
在函數中定義的一些基本類型的變數和對象的引用變數都在函數的棧內存中分配。
當在一段代碼塊定義一個變數時，Java就在棧中為這個變數分配內存空間，當超過變數的作用域後，Java會自動釋放掉為該變數所分配的內存空間，該內存空間可以立即被另作他用。
堆內存用來存放由new創建的對象和數組。
在堆中分配的內存，由Java虛擬機的自動垃圾回收器來管理。
在堆中產生了一個數組或對象後，還可以在棧中定義一個特殊的變數，讓棧中這個變數的取值等於數組或對象在堆內存中的首地址，棧中的這個變數就成了數組或對象的引用變數。
引用變數就相當於是為數組或對象起的一個名稱，以後就可以在程序中使用棧中的引用變數來訪問堆中的數組或對象。