㈠ 怎样增加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()并不会强制释放内存,虚拟机会尽最大努力从所有丢弃的对象中回收了空间。