如何从Java生成大型（1gb）示例gc日志文件

我需要一个大的GC日志文件来对我的日志分析器应用程序进行基准测试。请建议生成示例GC日志文件的最佳方法

我在下面找到了这个小代码，它每100毫秒分配2MB内存

class MyTask extends TimerTask{

    static final int MB = 1024 * 1024; //GB= 1024 * 1024 * 1024
    @Override
    public void run() {
        byte[] a1 = new byte[2 * MB];
        a1[1] = 1;
        Runtime runtime = Runtime.getRuntime();
        System.out.print("total :" + (runtime.totalMemory() / 1024)+ " KB\n");
        long free = runtime.freeMemory() / 1024;
        System.out.print("free:" + free+ " KB\n");
    }
}

public class MemoryAllocationTest {
    static public void main(String[] arg){
        Timer timer = new Timer();
        timer.schedule(new MyTask(), 100, 100);
    }
}

现在我可以使用VM选项生成gc日志文件了

-XX:+DisableExplicitGC
-XX:+PrintGCDetails
-XX:+PrintGCApplicationStoppedTime
-XX:+PrintGCApplicationConcurrentTime
-XX:+PrintGCDateStamps
-Xloggc:gclog.log

生成200-300 MB的文件需要几天的时间。但是我需要>=1GB的文件大小，并且具有不同类型/种类的gc事件

---

我该怎么做呢？

您可以强制运行java垃圾收集器

删除

-XX:+DisableExplicitGC

选项

即

/**
*使用更少的内存，例如jvm选项-Xms64m-Xmx64m
*/
公共级垃圾发电机{
私有静态字符串generateArbage（）{
StringBuilder b=新的StringBuilder（）；
对于（长i=0；i<100_000；i++）{
b、 附加（第（i）项的长值）；
}
返回b.toString（）；
}
专用静态最终最大长度=100_000_000L；
专用静态最终长TP=10_000_000L；
公共静态void main（字符串[]args）{
System.out.println（“垃圾生成已启动”）；
//我们需要更多的垃圾，所以不是ArrayList
最终列表=新的LinkedList（）；
长时间完成=0升；
长i=0L；
最终锁定=新的可重入锁定（）；
int cpulogicCores=Runtime.getRuntime（）.availableProcessors（）；
ExecutorService exec=Executors.newFixedThreadPool（CpuLogicCores）；
做{
最终倒计时闩锁倒计时=新倒计时闩锁（CPU）；
对于（int k=0；k{
字符串垃圾=generateGarbage（）；
lock.lock（）；
试一试{
添加（垃圾）；
}最后{
lock.unlock（）；
}
倒计时；
});
}
试一试{
倒计时；
}捕捉（中断异常e）{
Thread.currentThread（）.interrupt（）；
}
list.clear（）；
++一,；
如果（0==（i%TP））
System.out.println（“%”+长值of（完成+=10L））；
//强制运行gc，检查jvm命令行选项是否未禁用
Runtime.getRuntime（）.gc（）；
}而（i

您可以强制运行java垃圾收集器

删除

-XX:+DisableExplicitGC

选项

即

/**
*使用更少的内存，例如jvm选项-Xms64m-Xmx64m
*/
公共级垃圾发电机{
私有静态字符串generateArbage（）{
StringBuilder b=新的StringBuilder（）；
对于（长i=0；i<100_000；i++）{
b、 附加（第（i）项的长值）；
}
返回b.toString（）；
}
专用静态最终最大长度=100_000_000L；
专用静态最终长TP=10_000_000L；
公共静态void main（字符串[]args）{
System.out.println（“垃圾生成已启动”）；
//我们需要更多的垃圾，所以不是ArrayList
最终列表=新的LinkedList（）；
长时间完成=0升；
长i=0L；
最终锁定=新的可重入锁定（）；
int cpulogicCores=Runtime.getRuntime（）.availableProcessors（）；
ExecutorService exec=Executors.newFixedThreadPool（CpuLogicCores）；
做{
最终倒计时闩锁倒计时=新倒计时闩锁（CPU）；
对于（int k=0；k{
字符串垃圾=generateGarbage（）；
lock.lock（）；
试一试{
添加（垃圾）；
}最后{
lock.unlock（）；
}
倒计时；
});
}
试一试{
倒计时；
}捕捉（中断异常e）{
Thread.currentThread（）.interrupt（）；
}
list.clear（）；
++一,；
如果（0==（i%TP））
System.out.println（“%”+长值of（完成+=10L））；
//强制运行gc，检查jvm命令行选项是否未禁用
Runtime.getRuntime（）.gc（）；
}而（i

运行code i多线程会使GC工作更困难（不仅仅是一个计时器线程）…运行code i多线程会使GC工作更困难（不仅仅是一个计时器线程）。。。

/**
 * Use less memory, for example jvm options -Xms64m -Xmx64m
 */
public class GarbageGenerator {

    private static String generateGarbage() {
        StringBuilder b = new StringBuilder();
        for (long i = 0; i < 100_000; i++) {
            b.append(Long.valueOf(i));
        }
        return b.toString();
    }

    private static final long MAX = 100_000_000L;
    private static final long TP = 10_000_000L;

    public static void main(String[] args) {
        System.out.println("Garbage generation started");
        // we need more garbage, so not an ArrayList
        final List<String> list = new LinkedList<>();
        long done = 0L;
        long i = 0L;
        final Lock lock = new ReentrantLock();
        int cpuLogicalCores = Runtime.getRuntime().availableProcessors();
        ExecutorService exec = Executors.newFixedThreadPool(cpuLogicalCores);
        do {
            final CountDownLatch countDown = new CountDownLatch(cpuLogicalCores);
            for (int k = 0; k < cpuLogicalCores; k++) {
                exec.execute(() -> {
                    String garbage = generateGarbage();
                    lock.lock();
                    try {
                        list.add(garbage);
                    } finally {
                        lock.unlock();
                    }
                    countDown.countDown();
                });
            }
            try {
                countDown.await();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            list.clear();
            ++i;
            if (0 == (i % TP))
                System.out.println("%" + Long.valueOf(done += 10L));
            // force run gc, check that not disabled by jvm command line options
             Runtime.getRuntime().gc();
        } while (i < MAX);
        exec.shutdown();
        try {
            exec.awaitTermination(365, TimeUnit.DAYS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Garbage generation end");
    }

}