java的內存

㈠ 怎樣增加java執行內存

方法如下：
1、打開eclipse配置文件eclipse.ini，更改把-Xmx（其數值代表jvm可以使用的最大內存數）
2、運行java程序時，選擇run->run configuration->arguments,輸入-Xms100M -Xmx800M（-Xms代表jvm啟動時分配的內存大小，-Xmx代表可最大分配多少內存）。

3、如果修改web伺服器的內存可以通過window->preference->myeclipse->servers->伺服器名稱->伺服器名稱+版本->jdk下面修改內存。
例如：-Xms512m -Xmx1024m -XX:PermSize=256m

㈡ Java執行內存一般多大

我運行了myeclipse6.5+mysql直接沾了這么多。不過要看項目的大小。打開的項目大的話，就不止這么點了。500mb都有。

㈢ 關於java的內存問題

其實你就是想對java虛擬機機制有所了解，可以參考http://wenku..com/view/6a67ca2bcfc789eb172dc86c.html或者去網路java虛擬機詳解，一般在第二章節。

你提的問題只不過是jvm介紹中的比較局部的幾個地方，涉及到常量池，堆內存，棧內存等概念。參考這個手冊都能了解到。尤其要區別什麼是變數聲明，什麼是變數創建，什麼是變數引用。然後就是對特殊情況的了解。比如int i=127.這個127其實是在常量池裡的，當你用integer a = new Integer("127"). integer b = new integer("127").的時候，他們是指向同一個地址的，但是當你創建new Integer("128")的時候創建出的卻是兩個對象，但是都是在常量池裡面的，這些概念在jvm虛擬機詳解裡面都有。

第二個問題和第三個問題其實是很明確的對比。第二個問題，首先在堆內存中創建出一個數組對象，有一個數組對象的地址，裡面放了兩個int常量的，也就是0，但是實際上都是指向同一個常量池地址，也就是0.
第三個問題則不同，person數組對象的地址，但是沒有為他制定長度，應該是無法通過編譯的。數組的創建必須標注最左邊那個索引的下標才對。即使你的問題是Person[] p = new Person[2];這個意思。其實也是創建了一個數組對象，指向一個數組地址，然後數組對象裡面存放的是兩個null的值，還沒有分配內存空間和地址。

㈣ 64位 java 內存最大多少

java7最大內存只能設置為1024M，再大就不行了
java8可以設置特別大，看你的電腦內存情況而定，比如你內存8G，你就可以設置java用6G，留2G給你系統用

㈤ JAVA的運行內存怎麼看

public class RuntimeDemo01{
public static void main(String args[]){
Runtime run = Runtime.getRuntime(); // 通過Runtime類的靜態方法進行實例化操作
System.out.println("JVM最大內存量：" + run.maxMemory()) ; // 觀察最大的內存，根據機器的不同，環境也會有所不同
System.out.println("JVM空閑內存量：" + run.freeMemory()) ; // 取得程序運行的空閑內存 ｝｝

㈥ 如何獲取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 怎麼把數據存到內存中

這里你採納與否沒關系，給你說說編程與內存的關系。
你定義的任何變數，常量，類，方法等等，其實都在內存中，沒有所謂的把數據存內存中，這概念，你可以想一下電腦重啟或關機後，內存中的所有數據，都會丟失，除非你保存到磁碟中去。
在內存中的數據有兩塊，第一、緩沖，一般寫數據到磁碟的時候開辟出來的內存空間；第二、緩存，一般是從磁碟讀數據到內存中開辟出來的內存空間。會這么使用，原因很簡單，磁碟讀寫數據速度與內存不一致（磁碟的存取效率遠遠小於內存的存取效率），為了提高數據的存取效率，才會這么乾的。
一般而言，java中的所謂數據，大部分都是類，從自動引用計數的概念來分析，你想把對象長久的放在內存中，不會被垃圾回收機制釋放，注意制葯有一個對象在使用／引用你的數據，這條數據就會存在內存中。所以，想servlet中的全局配置參數，隨時可以取到還是唯一一份，你可以參考一下。
另外內存使用分堆與棧，堆在面向對象編程中存儲對象的，棧是方法或函數執行的時候臨時開辟的存儲空間，方法或函數執行完畢就會釋放。
希望我的回復能幫助到你，採納與否沒關系。有更好的答案，我就隱藏我的回復。

㈧ 怎樣用Java獲取內存中的數據

可以考慮使用內存映射文件：java.nio.MappedByteBuffer，主要適合放入較大的數據進入系統內存
可以考慮使用：java.nio.ByteBuffer.allocateDirect()方法進行分配，可以將一些不適合放入堆里的數據放入系統內存
還可以採用java本地調用的方式，實現對系統自身內存的掌控與調度，這種方式可以讓你靈活的訪問系統的內存。
java的堆放入的對象尺度是有限制的，這里建議參考BigMemory 的實現機制以及內存管理機制
如果自己管理內存的話，建議參考其他語言對內存管理的方式。
你可以把數據放入線性數據結構中（這些數據是在系統內存中，而非jvm管理的內存里），這樣就不存在分代問題，可以由你的應用在適當的時候清理系統的內存。這樣，你的內存模型-釋放機制就與jvm的內存管理機制處於一個互不幹擾的異行線上。

㈨ Java中內存分為幾塊

你說的是jvm的內存空間吧。
在方法（代碼塊）中定義一個變數時，java就在棧中為這個變數分配JVM內存空間，當超過變數的作用域後，java會自動釋放掉為該變數所分配的JVM內存空間；而在堆中分配的JVM內存由java虛擬機的自動垃圾回收器來管理。

JVM內存區域組成

JVM內存分四種：

1、棧區（stacksegment）—由編譯器自動分配釋放,存放函數的參數值，局部變數的值等，具體方法執行結束之後，系統自動釋放JVM內存資源

2、堆區（heapsegment）—一般由程序員分配釋放，存放由new創建的對象和數組，jvm不定時查看這個對象，如果沒有引用指向這個對象就回收

3、靜態區（datasegment）—存放全局變數，靜態變數和字元串常量，不釋放

4、代碼區（codesegment）—存放程序中方法的二進制代碼，而且是多個對象共享一個代碼空間區域

在方法（代碼塊）中定義一個變數時，java就在棧中為這個變數分配JVM內存空間，當超過變數的作用域後，java會自動釋放掉為該變數所分配的JVM內存空間；在堆中分配的JVM內存由java虛擬機的自動垃圾回收器來管理，堆的優勢是可以動態分配JVM內存大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配JVM內存的。缺點就是要在運行時動態分配JVM內存，存取速度較慢；棧的優勢是存取速度比堆要快，缺點是存在棧中的數據大小與生存期必須是確定的無靈活性。

◆java堆由Perm區和Heap區組成，Heap區則由Old區和New區組成，而New區又分為Eden區,From區,To區，Heap={Old+NEW={Eden,From,To}}，見圖1所示。

Heap區分兩大塊，一塊是NEWGeneration,另一塊是OldGeneration.在NewGeneration中，有一個叫Eden的空間，主要是用來存放新生的對象，還有兩個SurvivorSpaces（from,to）,它們用來存放每次垃圾回收後存活下來的對象。在OldGeneration中，主要存放應用程序中生命周期長的JVM內存對象，還有個PermanentGeneration，主要用來放JVM自己的反射對象，比如類對象和方法對象等。

在NewGeneration塊中，垃圾回收一般用Copying的演算法，速度快。每次GC的時候，存活下來的對象首先由Eden拷貝到某個SurvivorSpace,當SurvivorSpace空間滿了後,剩下的live對象就被直接拷貝到OldGeneration中去。因此，每次GC後，EdenJVM內存塊會被清空。在OldGeneration塊中，垃圾回收一般用mark-compact的演算法，速度慢些，但減少JVM內存要求.

垃圾回收分多級，0級為全部(Full)的垃圾回收，會回收OLD段中的垃圾；1級或以上為部分垃圾回收，只會回收NEW中的垃圾，JVM內存溢出通常發生於OLD段或Perm段垃圾回收後，仍然無JVM內存空間容納新的Java對象的情況。

JVM調用GC的頻度還是很高的，主要兩種情況下進行垃圾回收：當應用程序線程空閑；另一個是JVM內存堆不足時，會不斷調用GC，若連續回收都解決不了JVM內存堆不足的問題時，就會報outofmemory錯誤。因為這個異常根據系統運行環境決定，所以無法預期它何時出現。

根據GC的機制，程序的運行會引起系統運行環境的變化，增加GC的觸發機會。為了避免這些問題，程序的設計和編寫就應避免垃圾對象的JVM內存佔用和GC的開銷。顯示調用System.GC()只能建議JVM需要在JVM內存中對垃圾對象進行回收，但不是必須馬上回收，一個是並不能解決JVM內存資源耗空的局面，另外也會增加GC的消耗。

◆當一個URL被訪問時，JVM內存區域申請過程如下：

A.JVM會試圖為相關Java對象在Eden中初始化一塊JVM內存區域

B.當Eden空間足夠時，JVM內存申請結束。否則到下一步

C.JVM試圖釋放在Eden中所有不活躍的對象（這屬於1或更高級的垃圾回收）,釋放後若Eden空間仍然不足以放入新對象，則試圖將部分Eden中活躍對象放入Survivor區

D.Survivor區被用來作為Eden及OLD的中間交換區域，當OLD區空間足夠時，Survivor區的對象會被移到Old區，否則會被保留在Survivor區

E.當OLD區空間不夠時，JVM會在OLD區進行完全的垃圾收集（0級）

F.完全垃圾收集後，若Survivor及OLD區仍然無法存放從Eden復制過來的部分對象，導致JVM無法在Eden區為新對象創建JVM內存區域，則出現"outofmemory錯誤"

㈩ java 怎麼釋放內存

cc=null;就可以了。java 虛擬機會自己調用gc()方法去釋放內存。

顯示的調用System.gc()或Runtime.getRuntime().gc()也是可以的。調用了gc()並不會強制釋放內存，虛擬機會盡最大努力從所有丟棄的對象中回收了空間。