java应用堆空间问题

今天突然想到一个问题，我们项目用到了一个ConstantService类，这个类在spring容器初始化时创建

import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;

import org.apache.log4j.Logger;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

public class ConstantService {

    private static final Logger log = Logger.getLogger(ConstantService.class);
    
    private static Map<String, String> constantsMap = null;
    private static String DEFAULT_FILENAME = "Constants.properties";
    private String configfile;

    public void init() {
        loadConstants();
    }

    private boolean loadConstants() {
        if (constantsMap == null)
            constantsMap = new HashMap();
        boolean retFlag = true;
        log.info("开始初始化常量配置!");
        URL files[] = genRealConfigFile();
        URL aurl[] = files;
        int i = 0;
        for (int j = aurl.length; i < j; ++i) {
            URL strFileName = aurl[i];
            Properties props = new Properties();
            try {
                props.load(strFileName.openStream());
                for (Iterator localIterator = props.entrySet().iterator(); localIterator
                        .hasNext();) {
                    Map.Entry entry = (Map.Entry) localIterator.next();
                    if (constantsMap.containsKey((String) entry.getKey()))
                        log.error(LoggerUtils.format(
                                "常量初始化时，常量名[#1]重复。框架采用覆盖原则!",
                                new String[] { (String) entry.getKey() }));
                    constantsMap.put((String) entry.getKey(), (String) entry
                            .getValue());
                }
            } catch (FileNotFoundException e) {
                retFlag = false;
                log.error(LoggerUtils.format("Can't find config file:[#1]",
                        new String[] { strFileName.getFile() }));
            } catch (IOException e) {
                retFlag = false;
                log.error(LoggerUtils.format(
                        "Error when loading config file:[#1]",
                        new String[] { strFileName.getFile() }));
            }
        }
        log.info(LoggerUtils.format("常量配置初始化完毕!共[#1]个常量",
                new String[constantsMap.size()]));
        log.info(constantsMap);
        return retFlag;
    }

    private URL[] genRealConfigFile() {
        String[] aryConfigFile = (String[]) null;
        if (!(StringUtils.hasText(this.configfile)))
            aryConfigFile = new String[] { DEFAULT_FILENAME };
        else
            aryConfigFile = StringUtils.tokenizeToStringArray(this.configfile,
                    ",");
        ArrayList tmpList = new ArrayList();
        String[] arrayOfString1 = aryConfigFile;
        int i = 0;
        for (int j = arrayOfString1.length; i < j; ++i) {
            String strResource = arrayOfString1[i];
            ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
            try {
                Resource[] resources = resourcePatternResolver
                        .getResources(strResource);
                for (int k = 0; k < resources.length; ++k)
                    tmpList.add(resources[k].getURL());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        URL[] ret = new URL[tmpList.size()];
        return ((URL[]) tmpList.toArray(ret));
    }

      public static String getConstant(String strKey)
      {
        return StringUtils.trimText((String)constantsMap.get(strKey));
      }

      public static Map<String, String> getConstants(String strPreFix)
      {
        if (!(StringUtils.hasText(strPreFix)))
          return null;

        Map retMap = null;
        Iterator itrKey = constantsMap.keySet().iterator();
        while (itrKey.hasNext()) {
          String strTmpKey = (String)itrKey.next();
          if (strTmpKey.startsWith(strPreFix + ".")) {
            if (retMap == null)
              retMap = new HashMap();

            retMap.put(strTmpKey.substring(strPreFix.length() + 1), (String)constantsMap.get(strTmpKey));
          }
        }

        return retMap;
      }
      
    public static Map getConstantsMap() {
        return constantsMap;
    }

    public static void setConstantsMap(Map constantsMap) {
        ConstantService.constantsMap = constantsMap;
    }

    public static String getDEFAULT_FILENAME() {
        return DEFAULT_FILENAME;
    }

    public static void setDEFAULT_FILENAME(String default_filename) {
        DEFAULT_FILENAME = default_filename;
    }

    public String getConfigfile() {
        return configfile;
    }

    public void setConfigfile(String configfile) {
        this.configfile = configfile;
    }
}

    <!-- 初始化加载文本 -->
    <bean class="com.cvicse.jaf.utils.ConstantService"
        init-method="init">
        <!-- 初始化和加载常量文件 -->
        <property name="configfile"
            value="constant/Constants*.properties" />
    </bean>

在项目的其它很多地方都用到了类似如下的代码

String jmsIp = ConstantService.getConstant("jmsIp");
String uuapJmsUserName = ConstantService.getConstant("uuapJmsUserName");
String uuapJmsPwd = ConstantService.getConstant("uuapJmsPwd");

我是这样理解的ConstantService这个类在spring容器初始化后单例模式实例化，且在spring容器存活期间一直持有，那么这个类在spring容器的生命周期里只会

加载一次，且一直被容器持有。

然后我又想，因为对象是保存在堆内存中的，也就是说整个项目会使用同一个堆，以前因为项目在导出excel数据过多时，而导致堆内存不足，手动设置过开发使用的tomcat生产使用的和websphere，jvm内存大小,如下：

 -Xms800m -Xmx800m -XX:PermSize=64M -XX:MaxNewSize=512m -XX:MaxPermSize=256m

在应用程序服务器>server1>进程定义>Java虚拟机>配置里面设置初始堆大小和最大堆大小

而我重写一个带main方法的java类，run as Java Application,调用这个ConstantService的静态属性，并不会得到已经配置过的静态属性

然后我就想了是不是我们的jvm可以创建多个jvm实例，而整个tomcat就是一个jvm实例，我新创建的这个带main方法的类运行时也会唯一对应一个jvm实例，唯一对应自己的堆空间。

然后我查了下，百度知道上有个人的回答基本吻合了我的想法。

Java项目跟jvm进程数量没什么直接关系。通常我们用java 命令运行一个程序就会启动一个jvm进程，就是你所说的jvm实例。可以看看tomcat的启动脚本(非常复杂)，但最终是通过一个java命令启动tomcat容器。webapp运行于tomcat容器基础之上，和tomcat同属于一个jvm进程是必然的。至于spring，容器的概念更多是逻辑上的，它仅仅是一个类(ApplicationContext,BeanFactory)的实例。web应用启动时加载一个WebApplicationContext实例，即我们所说的spring容器
追问
按你的意思理解 一个程序启动一个jvm实例，一个项目能保证在一个jvm里面吗 
另外 如果一个tomcat加载n各项目 他们之间彼此调用(比如通过http访问)，是不是跨jvm？
谢谢
回答
同一个项目可以部署在多台机器上，通过代理服务器转发请求给不同机器处理。这样就是个简单地web集群了。同一个tomcat下部署地应用自然是在一个jvm里。至于你说地通过http访问，其实只通过客户端通过http协议发起地，并不是服务器之间地调用关系。相当于客户端地两个请求

 

 

我使用