Java Spring Boot JPA Hibernate JVM堆未发布

下面是对更复杂设置的简化。我描述这个简单的例子来说明效果

我启动Spring Boot并调用一个方法。在这种方法中，MySQL数据库表的所有内容都是通过

Iterable<myPojo> myPojos = myPojoRepository.findAll();

因此，弹簧启动是空转后

但内存仍然没有释放

如何避免JVM堆在应用程序空闲后不释放？

这是应用程序空闲后VisualJM的结果：

char[]                        1.080.623.712 (21.0%)  24.040.578 (23.4%)
byte[]                        1.034.070.352 (20.1%)  17.280.824 (16.8%)
java.lang.String                768.935.872 (14.9%)  24.029.246 (23.4%)
java.lang.Object[]              556.181.104 (10.8%)   5.320.276 (5.1%)
org.hibernate.engine.internal.MutableEntityEntry
                                 231.287.232 (4.5%)   2.628.264 (2.5%)
org.hibernate.engine.spi.EntityKey
                                 224.752.040 (4.3%)   5.618.801 (5.4%)
byte[][]                         212.407.904 (4.1%)   3.318.832 (3.2%)
hello.web.model.MyPojo           185.852.968 (3.6%)   3.318.803 (3.2%)
java.util.HashMap$Node           145.238.976 (2.8%)   3.025.812 (2.9%)
com.mysql.jdbc.ByteArrayRow      132.752.120 (2.5%)   3.318.803 (3.2%)
org.hibernate.engine.internal.EntityEntryContext$ManagedEntityImpl
                                 126.156.720 (2.4%)   2.628.265 (2.5%)
hello.web.model.MyPojoCompoundKey
                                 120.376.680 (2.3%)   3.009.417 (2.9%)
java.util.HashMap$Node[]         108.307.328 (2.1%)      16.558 (0.0%)
java.lang.Float                   79.651.320 (1.5%)   3.318.805 (3.2%)
int[]                             41.885.056 (0.8%)      54.511 (0.0%)
java.util.LinkedHashMap$Entry     15.519.616 (0.3%)     242.494 (0.2%)
java.io.File                      11.323.392 (0.2%)     235.904 (0.2%)
org.springframework.boot.devtools.filewatch.FileSnapshot
                                  10.550.400 (0.2%)     219.800 (0.2%)
java.lang.String[]                 8.018.808 (0.1%)      52.031 (0.0%)
java.lang.reflect.Method           6.015.040 (0.1%)      37.594 (0.0%)
java.io.File[]                     2.283.528 (0.0%)      16.746 (0.0%)

我的effective-pom.xml显示使用了

hibernate5.0.9.Final

。 表

my_pojo

包含330万个条目

MyPojoRepository：

package hello.web.model;

import com.querydsl.core.types.Predicate;
import org.springframework.data.querydsl.QueryDslPredicateExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;

import java.util.List;

public interface MyPojoRepository
        extends PagingAndSortingRepository<MyPojo, Long>, 
                QueryDslPredicateExecutor<MyPojo> {

    List<MyPojo> findAll(Predicate predicate);    
}

包hello.web.model；
导入com.querydsl.core.types.Predicate；
导入org.springframework.data.querydsl.querydsl谓词执行器；
导入org.springframework.data.repository.paging和sortingrepository；
导入java.util.List；
公共接口MyPojoRepository
扩展分页和排序存储库，
QueryDSL谓词执行器{
列表findAll（谓词）；
}

MyPojo： 包hello.web.model

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.comparators.ComparatorChain;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Data
@Entity
@Builder
@AllArgsConstructor
@IdClass(MyPojoCompoundKey.class)
public class MyPojo implements Serializable, Comparable<MyPojo> {
    public MyPojo() {    }

    @Id
    private String myId1;
    @Id
    private String myId2;
    @Id
    private String myId3;
    private Float myId4;
    private String myId5;

    @Override
    public int compareTo(MyPojo o) {
        return this.getMyId3().compareTo(o.getMyId3());
    }
    protected boolean canEqual(Object other) {
        return other instanceof MyPojo;
    }
    public static void sortByMyId1MyId3(List<MyPojo> myPojos) {
        ComparatorChain chain = new ComparatorChain(Arrays.asList(
                new BeanComparator("myId1"),
                new BeanComparator("myId3")
        ));
        Collections.sort(myPojos, chain);
    }
}

导入lombok.allargsconstuctor；
进口龙目造船厂；
导入龙目数据；
导入org.apache.commons.beanutils.BeanComparator；
导入org.apache.commons.collections.comparators.ComparatorChain；
导入javax.persistence.Entity；
导入javax.persistence.Id；
导入javax.persistence.IdClass；
导入java.io.Serializable；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
@资料
@实体
@建筑商
@AllArgsConstructor
@IdClass（MyPojoCompoundKey.class）
公共类MyPojo实现了可序列化、可比较的{
公共MyPojo（）{}
@身份证
私有字符串myId1；
@身份证
私有字符串myId2；
@身份证
私有字符串myId3；
私有浮动myId4；
私有字符串myId5；
@凌驾
公共国际比较（MyPojo o）{
返回这个.getMyId3（）.compareTo（o.getMyId3（））；
}
受保护的布尔canEqual（对象其他）{
返回MyPojo的其他实例；
}
公共静态无效SortByD1MyID3（列出MyPOJO）{
ComparatorChain=新的ComparatorChain（Arrays.asList(
新BeanComparator（“myId1”），
新BeanComparator（“myId3”）
));
Collections.sort（myPojos，chain）；
}
}

myId1-3和myId5的平均长度为10个字符

所以再次强调：

---

如何避免JVM堆在应用程序空闲后不释放？

我想问题在于垃圾收集是如何工作的。这个想法是，只要内存没有泄漏，就不应该关心它。这不应该是你的问题，而是JVM的问题。垃圾收集器有几个选项可以修补。您可以请求他加入并从您的应用程序中使用

System.gc（）

启动一个集合。在我看来，将gc调用为@JChrist不是一个好主意。你不会得到确定性行为。所以在我的实际设置中，主内存会用完，然后交换内存。请放心，我的问题是针对所使用的框架。Java、JVM和垃圾收集在这里正常工作。性能（快30秒）以及内存占用（根据VisualVM，2.2 GB对4.1 GB）都要好得多。只要没有人知道负责缓存的QueryDsl的参数，我就会跳过对内存敏感的任务的QueryDsl。我想问题在于垃圾收集是如何工作的。这个想法是，只要内存没有泄漏，就不应该关心它。这不应该是你的问题，而是JVM的问题。垃圾收集器有几个选项可以修补。您可以请求他加入并从您的应用程序中使用

System.gc（）

启动一个集合。在我看来，将gc调用为@JChrist不是一个好主意。你不会得到确定性行为。所以在我的实际设置中，主内存会用完，然后交换内存。请放心，我的问题是针对所使用的框架。Java、JVM和垃圾收集在这里正常工作。性能（快30秒）以及内存占用（根据VisualVM，2.2 GB对4.1 GB）都要好得多。只要没有人知道负责缓存的QueryDsl的参数，我将跳过QueryDsl来执行内存敏感任务。

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.comparators.ComparatorChain;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Data
@Entity
@Builder
@AllArgsConstructor
@IdClass(MyPojoCompoundKey.class)
public class MyPojo implements Serializable, Comparable<MyPojo> {
    public MyPojo() {    }

    @Id
    private String myId1;
    @Id
    private String myId2;
    @Id
    private String myId3;
    private Float myId4;
    private String myId5;

    @Override
    public int compareTo(MyPojo o) {
        return this.getMyId3().compareTo(o.getMyId3());
    }
    protected boolean canEqual(Object other) {
        return other instanceof MyPojo;
    }
    public static void sortByMyId1MyId3(List<MyPojo> myPojos) {
        ComparatorChain chain = new ComparatorChain(Arrays.asList(
                new BeanComparator("myId1"),
                new BeanComparator("myId3")
        ));
        Collections.sort(myPojos, chain);
    }
}