减少Java堆大小

我正在使用Java8。我有一个服务可以从一个段落中提取所有名词。这在我的本地主机服务器上正常工作。我还让它在服务器上运行，没有任何问题。然而，它确实使用了大量内存。我需要将我的应用程序部署到

一种解决方案是，我可能可以从t1.micro升级到另一种实例类型。但我的预算很小，如果可能的话，我想避免这种情况

当我运行应用程序时，它尝试执行单词分块，它会出现以下错误：

调度失败；嵌套异常是java.lang.OutOfMemoryError:java堆空间]的根本原因
java.lang.OutOfMemoryError:java堆空间
位于opennlp.tools.ml.model.AbstractModelReader.getParameters（AbstractModelReader.java:148）
位于opennlp.tools.ml.maxent.io.GISModelReader.constructModel（GISModelReader.java:75）
位于opennlp.tools.ml.model.GenericModelReader.constructModel（GenericModelReader.java:59）
位于opennlp.tools.ml.model.AbstractModelReader.getModel（AbstractModelReader.java:87）
位于opennlp.tools.util.model.GenericModelSerializer.create（GenericModelSerializer.java:35）
位于opennlp.tools.util.model.GenericModelSerializer.create（GenericModelSerializer.java:31）
在opennlp.tools.util.model.BaseModel.finishLoadingArtifacts（BaseModel.java:328）上
位于opennlp.tools.util.model.BaseModel.loadModel（BaseModel.java:256）
在opennlp.tools.util.model.BaseModel.（BaseModel.java:179）
在opennlp.tools.parser.ParserModel.（ParserModel.java:180）
位于com.jobs.spring.service.lang.LanguageChunkerServiceImpl.init（LanguageChunkerServiceImpl.java:35）
位于com.jobs.spring.service.lang.LanguageChunkerServiceImpl.GetNonys（LanguageChunkerServiceImpl.java:46）

问题

有没有办法：

减少从段落中提取名词时使用的内存量

使用不同的api，否则不会占用那么多内存

一种配置以满足需求的方法

代码示例：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Set;

import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import opennlp.tools.cmdline.parser.ParserTool;
import opennlp.tools.parser.Parse;
import opennlp.tools.parser.Parser;
import opennlp.tools.parser.ParserFactory;
import opennlp.tools.parser.ParserModel;
import opennlp.tools.util.InvalidFormatException;

@Component("languageChunkerService")
@Transactional
public class LanguageChunkerServiceImpl implements LanguageChunkerService {

    private Set<String> nouns = null;
    private InputStream modelInParse = null;
    private ParserModel model = null;
    private Parser parser = null;

    public void init() throws InvalidFormatException, IOException {
        ClassLoader classLoader = getClass().getClassLoader();
        File file = new File(classLoader.getResource("en-parser-chunking.bin").getFile());
        modelInParse = new FileInputStream(file.getAbsolutePath());

        // load chunking model
        model = new ParserModel(modelInParse); // line 35
        // create parse tree
        parser = ParserFactory.create(model);
    }

    @Override
    public Set<String> getNouns(String sentenceToExtract) {
        Set<String> extractedNouns = new HashSet<String>();
        nouns = new HashSet<>();
        try {
            if (parser == null) {
                init();
            }

            Parse topParses[] = ParserTool.parseLine(sentenceToExtract, parser, 1);

            // call subroutine to extract noun phrases
            for (Parse p : topParses) {
                getNounPhrases(p);
            }

            // print noun phrases
            for (String s : nouns) {
                String word = s.replaceAll("[^a-zA-Z ]", "").toLowerCase();// .split("\\s+");
                //System.out.println(word);
                extractedNouns.add(word);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (modelInParse != null) {
                try {
                    modelInParse.close();
                } catch (IOException e) {
                }
            }
        }
        return extractedNouns;
    }

    // recursively loop through tree, extracting noun phrases
    private void getNounPhrases(Parse p) {
        if (p.getType().equals("NN")) { // NP=noun phrase
            // System.out.println(p.getCoveredText()+" "+p.getType());
            nouns.add(p.getCoveredText());
        }
        for (Parse child : p.getChildren())
            getNounPhrases(child);
    }
}

导入java.io.File；
导入java.io.FileInputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.util.HashSet；
导入java.util.Set；
导入org.springframework.stereotype.Component；
导入org.springframework.transaction.annotation.Transactional；
导入opennlp.tools.cmdline.parser.ParserTool；
导入opennlp.tools.parser.Parse；
导入opennlp.tools.parser.parser；
导入opennlp.tools.parser.ParserFactory；
导入opennlp.tools.parser.ParserModel；
导入opennlp.tools.util.InvalidFormatException；
@组件（“languageChunkerService”）
@交易的
公共类LanguageChunkerService Impl实现LanguageChunkerService{
私有集合名词=null；
私有InputStream modelInParse=null；
private ParserModel model=null；
私有解析器=null；
public void init（）引发InvalidFormatException，IOException{
ClassLoader ClassLoader=getClass（）.getClassLoader（）；
File File=新文件（classLoader.getResource（“en parser chunking.bin”）.getFile（））；
modelInParse=newfileinputstream（file.getAbsolutePath（））；
//负载分块模型
model=newparsermodel（modelInParse）；//第35行
//创建解析树
parser=ParserFactory.create（model）；
}
@凌驾
公共集合GetNonnons（字符串语句提取）{
Set extractednowns=newhashset（）；
名词=新HashSet（）；
试一试{
if（解析器==null）{
init（）；
}
Parse topParses[]=ParserTool.parseLine（sentenceToExtract，parser，1）；
//调用子例程提取名词短语
for（解析p:topParses）{
短语（p）；
}
//印刷名词短语
for（字符串s：名词）{
字符串word=s.replaceAll（“[^a-zA-Z]”，“”）。toLowerCase（）；//.split（“\\s+”）；
//System.out.println（word）；
提取名词。添加（单词）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}最后{
if（modelInParse！=null）{
试一试{
modelInParse.close（）；
}捕获（IOE异常）{
}
}
}
返回提取的名词；
}
//递归循环遍历树，提取名词短语
私有void getnounomphrases（Parse p）{
if（p.getType（）.equals（“NN”）{//NP=名词短语
//System.out.println（p.getCoveredText（）+“”+p.getType（））；
名词.add（p.getCoveredText（））；
}
for（解析子对象：p.getChildren（））
英语短语（儿童）；
}
}

更新

Tomcat8配置：

---

首先，您应该尝试优化代码。首先使用regex和precompile语句，然后再使用replaceAll，因为replaceAll替换了内存中的内容。（）

其次，不应将解析后的句子存储在数组中。第三个提示：您应该尝试使用bytebuffer将内存分配给数组。另一个可能对您影响最大的提示是，您应该使用BufferedReader来读取分块文件。（）

在此之后，您应该已经看到更少的内存使用。如果这些提示对您没有帮助，请提供内存转储/分配图

还有一个提示：哈希集占用的内存是无序列表的5.5倍。（）

我看不出这个答案有什么正确之处。使用

Pattern

而不是

replaceAll

可能会影响速度，但不会影响内存。使用

ByteBuffer

而不是数组，也没有意义，除非他使用的代码需要缓冲区

BufferedReader

与此无关，因为它还影响速度而不是内存使用。最后，有一件事确实会影响内存（

HashSet

），它也会戏剧性地影响速度。如果他没有足够的预算，并且

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Set;

import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import opennlp.tools.cmdline.parser.ParserTool;
import opennlp.tools.parser.Parse;
import opennlp.tools.parser.Parser;
import opennlp.tools.parser.ParserFactory;
import opennlp.tools.parser.ParserModel;
import opennlp.tools.util.InvalidFormatException;

@Component("languageChunkerService")
@Transactional
public class LanguageChunkerServiceImpl implements LanguageChunkerService {

    private Set<String> nouns = null;
    private InputStream modelInParse = null;
    private ParserModel model = null;
    private Parser parser = null;

    public void init() throws InvalidFormatException, IOException {
        ClassLoader classLoader = getClass().getClassLoader();
        File file = new File(classLoader.getResource("en-parser-chunking.bin").getFile());
        modelInParse = new FileInputStream(file.getAbsolutePath());

        // load chunking model
        model = new ParserModel(modelInParse); // line 35
        // create parse tree
        parser = ParserFactory.create(model);
    }

    @Override
    public Set<String> getNouns(String sentenceToExtract) {
        Set<String> extractedNouns = new HashSet<String>();
        nouns = new HashSet<>();
        try {
            if (parser == null) {
                init();
            }

            Parse topParses[] = ParserTool.parseLine(sentenceToExtract, parser, 1);

            // call subroutine to extract noun phrases
            for (Parse p : topParses) {
                getNounPhrases(p);
            }

            // print noun phrases
            for (String s : nouns) {
                String word = s.replaceAll("[^a-zA-Z ]", "").toLowerCase();// .split("\\s+");
                //System.out.println(word);
                extractedNouns.add(word);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (modelInParse != null) {
                try {
                    modelInParse.close();
                } catch (IOException e) {
                }
            }
        }
        return extractedNouns;
    }

    // recursively loop through tree, extracting noun phrases
    private void getNounPhrases(Parse p) {
        if (p.getType().equals("NN")) { // NP=noun phrase
            // System.out.println(p.getCoveredText()+" "+p.getType());
            nouns.add(p.getCoveredText());
        }
        for (Parse child : p.getChildren())
            getNounPhrases(child);
    }
}