Heap and Perm size

最新推荐文章于 2020-08-27 08:30:34 发布
最新推荐文章于 2020-08-27 08:30:34 发布 · 128 阅读 · 0

本文详细解析了JVM启动时常用的内存设置参数，包括最小堆内存(-Xms)、最大堆内存(-Xmx)、永久代初始大小(-XX:PermSize)及最大大小(-XX:MaxPermSize)，帮助读者更好地理解并配置Java应用的运行环境。
-Xms256m -Xmx256m -XX:PermSize=256m -XX:MaxPermSize=256m
iteye_6775
关注
JVM 垃圾回收机制: CMS和G1的具体代码实现和优化建议 Taming the Java Garbage Collector with CMS and G1
AI天才研究院
07-28 1315
由于Java的垃圾回收机制的历史渊源、目前发展的趋势及其在性能上的影响力，使得Java开发者经常会被它的自动内存管理所吸引。随着互联网的兴起、云计算平台的普及以及移动终端设备的流行，越来越多的企业开始面临“海量数据”的问题，而在解决海量数据时，就不可避免地需要通过分布式集群的方式来处理。对于Java这样的高级语言来说，它独特的运行环境及强大的第三方库支持，使得它成为构建分布式应用系统的首选语言之一。正如一般的分布式应用系统一样，Java编程语言也提供了对内存管理的机制来帮助用户管理内存资源。
JVM高频面试基本问题与知识点整理
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
01-16 86万+
JVM高频面试基本问题与知识点整理
转 《JVM HeapSize Permsize》
coolfiry
11-07 285
java虽然是自动回收内存，但是应用程序，尤其服务器程序最好根据业务情况指明内存分配限制。否则可能导致应用程序宕掉。 举例说明含义：-Xms128m 表示JVM Heap(堆内存)最小尺寸128MB，初始分配 -Xmx512m 表示JVM Heap(堆内存)最大允许的尺寸256MB，按需分配。 说明：如果-Xmx不指定或者指定偏小，应用可能会导致java.lang.OutOfMe...
java出现[Heap size],[PermGen space],[Java heap space ]的解决方法
自由时飞扬 搬家拉 http://www.meiriyouke.net
03-13 288
//首先检查程序有没有限入死循环 排除程序本身的问题 答案大致有这两种解决方法： 1、设置环境变量 解决方法：手动设置Heap size 修改TOMCAT_HOME/bin/catalina.sh 添加：JAVA_OPTS= '-Xms32m -Xmx512m' 可以根据自己机器的内存进行更改。 2、java -Xms32m -Xmx800m className 就是在执行JAVA类文件...
java heap space解决方法和JVM参数设置
追梦船的专栏
12-06 1万+
在JVM中如果98%的时间是用于GC(Garbage Collection)且可用的 Heap size 不足2%的时候将抛出异常信息，java.lang.OutOfMemoryError: Java heap space。  所以产生这个异样的原因通常有两种： 1.程序中出现了死循环 2.程序占用内存太多，超过了JVM堆设置的最大值。 对于第一种情况，需要自己查看程序代码，这
【JVM】Perm Generation与Heap的关系
简简单单兔呦
08-09 2432
Java 6 stores all the constant pool and Class information in the Perm Gen Java 7 only stores the class information in the Perm Gen. The String literal pool is on the heap. Java 8 has no Perm Gen. Th...
JVM参数及默认值
码灵的博客
08-27 3432
简介 Java启动参数共分为三类 其一是标准参数（-），所有的JVM实现都必须实现这些参数的功能，而且向后兼容； 其二是非标准参数（-X），默认jvm实现这些参数的功能，但是并不保证所有jvm实现都满足，且不保证向后兼容； 其三是非Stable参数（-XX），此类参数各个jvm实现会有所不同，将来可能会随时取消，需要慎重使用； 一、JVM标准参数(-) JVM的标准参数都是以”-“开头，通过输入”java -help”或者”java -?”，可以查看JVM标准参数列表。 如 JVM标准参数的
用多轮迭代策略，修改代码：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #include <time.h> typedef struct { int node_id; double gain; } HeapItem; typedef struct { int id; int area; } Node; typedef struct { int num_nodes; int* nodes; double cost; int count0; int count1; } HyperEdge; typedef struct EdgeList { int edge_id; struct EdgeList* next; } EdgeList; Node* nodes; HyperEdge* edges; int* part; int* locked; double* gain; int n, m; int area0, area1; int total_area; int amax; double ratio_factor; int L, U; EdgeList** node_edges; int* heap_index; int heap_size; int* heap_node_id; double* heap_gain; int compare_int(const void* a, const void* b) { return (*(int*)a - *(int*)b); } void add_edge_to_node(int node_id, int edge_id) { EdgeList* new_item = (EdgeList*)malloc(sizeof(EdgeList)); new_item->edge_id = edge_id; new_item->next = node_edges[node_id]; node_edges[node_id] = new_item; } void initial_partition() { L = (int)ceil(ratio_factor * total_area - amax); U = (int)floor(ratio_factor * total_area + amax); if (L < 0) L = 0; if (U > total_area) U = total_area; int* perm = (int*)malloc(n * sizeof(int)); for (int i = 0; i < n; i++) perm[i] = i; srand((unsigned int)time(NULL)); for (int i = n - 1; i > 0; i--) { int j = rand() % (i + 1); int temp = perm[i]; perm[i] = perm[j]; perm[j] = temp; } for (int i = 0; i < n; i++) part[i] = 1; area0 = 0; area1 = total_area; for (int i = 0; i < n; i++) { int node_id = perm[i]; if (area0 + nodes[node_id].area <= U) { part[node_id] = 0; area0 += nodes[node_id].area; area1 -= nodes[node_id].area; if (area0 >= L) break; } } if (area0 < L) { for (int i = 0; i < n; i++) { if (part[i] == 1 && area0 + nodes[i].area <= U) { part[i] = 0; area0 += nodes[i].area; area1 -= nodes[i].area; if (area0 >= L) break; } } } free(perm); } void init_edge_counts() { for (int i = 0; i < m; i++) { edges[i].count0 = 0; edges[i].count1 = 0; } for (int i = 0; i < m; i++) { for (int j = 0; j < edges[i].num_nodes; j++) { int node_id = edges[i].nodes[j]; if (part[node_id] == 0) edges[i].count0++; else edges[i].count1++; } } } double compute_cut_cost() { double cost = 0.0; for (极思 for (int i = 0; i < m; i++) { if (edges[i].count0 > 0 && edges[i].count1 > 0) { cost += edges[i].cost; } } return cost; } double compute_gain(int v) { double g = 0.0; int p = part[v]; EdgeList* cur = node_edges[v]; while (cur != NULL) { int e_id = cur->edge_id; HyperEdge* e = &edges[e_id]; int a = (p == 0) ? e->count0 : e->count1; int b = (p == 0) ? e->count1 : e->count0; // 关键修正：正确处理超边状态变化 if (a == 1 && b == 0) { g -= e->cost; // 当前节点是超边中唯一节点，移动会导致超边被切割 } else if (a == 1 && b > 0) { g += e->cost; // 当前节点是超边中唯一在分区的节点，移动会减少切割 } else if (a == 2 && b == 0) { g += e->cost; // 当前节点是超边中两个节点之一，移动会减少切割 } cur = cur->next; } return g; } void heap_swap(int i, int j) { int temp_id = heap_node_id[i]; double temp_gain = heap_gain[i]; heap_node_id[i] = heap_node_id[j]; heap_gain[i] = heap_gain[j]; heap_node_id[j] = temp_id; heap_gain[j] = temp_gain; heap_index[heap_node_id[i]] = i; heap_index[heap_node_id[j]] = j; } void heap_swim(int k) { while (k > 0) { int parent = (k - 1) / 2; if (heap_gain[k] > heap_gain[parent]) { heap_swap(k, parent); k = parent; } else break; } } void heap_sink(int k) { while (2 * k + 1 < heap_size) { int j = 2 * k + 1; if (j + 1 < heap_size && heap_gain[j + 1] > heap_gain[j]) j++; if (heap_gain[j] > heap_gain[k]) { heap_swap(k, j); k = j; } else break; } } void heap_push(int node_id, double gain_val) { heap_node_id[heap_size] = node_id; heap_gain[heap_size] = gain_val; heap_index[node_id] = heap_size; heap_swim(heap_size); heap_size++; } void heap_update(int idx, double new_gain) { double old_gain = heap_gain[idx]; heap_gain[idx] = new_gain; if (new_gain > old_gain) heap_swim(idx); else heap_sink(idx); } HeapItem heap_pop() { HeapItem top; top.node_id = heap_node_id[0]; top.gain = heap_gain[0]; heap_index[top.node_id] = -1; heap_swap(0, heap_size - 1); heap_size--; heap_sink(0); return top; } void fm() { init_edge_counts(); double current_cut = compute_cut_cost(); double best_cut = current_cut; int* best_part = (int*)malloc(n * sizeof(int)); memcpy(best_part, part, n * sizeof(int)); for (int i = 0; i < n; i++) locked[i] = 0; for (int i = 0; i < n; i++) gain[i] = compute_gain(i); heap_size = 0; heap_node_id = (int*)malloc(n * sizeof(int)); heap_gain = (double*)malloc(n * sizeof(double)); heap_index = (int*)malloc(n * sizeof(int)); for (int i = 0; i < n; i++) heap_index[i] = -1; for (int i = 0; i < n; i++) { heap_push(i, gain[i]); } while (heap_size > 0) { HeapItem item = heap_pop(); int v = item.node_id; if (locked[v]) continue; int new_area0 = area0; int new_area1 = area1; if (part[v] == 0) { new_area0 -= nodes[v].area; new_area1 += nodes[v].area; } else { new_area0 += nodes[v].area; new_area1 -= nodes[v].area; } if (new_area0 < L || new_area0 > U) { locked[v] = 1; continue; } int from_part = part[v]; int to_part = 1 - from_part; part[v] = to_part; area0 = new_area0; area1 = new_area1; current_cut -= gain[v]; if (current_cut < best_cut) { best_cut = current_cut; memcpy(best_part, part, n * sizeof(int)); } // 更新所有相关超边的状态 EdgeList* cur = node_edges[v]; while (cur != NULL) { int e_id = cur->edge_id; HyperEdge* e = &edges[e_id]; // 更新超边计数 if (from_part == 0) { e->count0--; e->count1++; } else { e->count0++; e->count1--; } // 更新所有关联节点的增益 for (int j = 0; j < e->num_nodes; j++) { int u = e->nodes[j]; if (u == v || locked[u]) continue; double old_gain = gain[u]; gain[u] = compute_gain(u); int idx = heap_index[u]; if (idx != -1) { heap_update(idx, gain[u]); } } cur = cur->next; } locked[v] = 1; } memcpy(part, best_part, n * sizeof(int)); free(best_part); free(heap_node_id); free(heap_gain); free(heap_index); } void output_partition() { int* part0_nodes = (int*)malloc(n * sizeof(int)); int* part1_nodes = (int*)malloc(n * sizeof(int)); int count0 = 0, count1 = 0; for (int i = 0; i < n; i++) { if (part[i] == 0) part0_nodes[count0++] = i; else part1_nodes[count1++] = i; } if (count0 > 0) qsort(part0_nodes, count0, sizeof(int), compare_int); if (count1 > 0) qsort(part1_nodes, count1, sizeof(int), compare_int); int min0 = (count0 > 0) ? part0_nodes[0] : n + 1; int min1 = (count1 > 0) ? part1_nodes[0] : n + 1; // 确保分区0包含最小ID节点 if (min0 <= min1) { printf("The node ids of the partition 0 are "); for (int i = 0; i < count0; i++) { if (i > 0) printf(", "); printf("%d", part0_nodes[i]); } printf("\nThe node ids of the partition 1 are "); for (int i = 0; i < count1; i++) { if (i > 0) printf(", "); printf("%d", part1_nodes[i]); } } else { printf("The node ids of the partition 0 are "); for (int i = 0; i < count1; i++) { if (i > 0) printf(", "); printf("%d", part1_nodes[i]); } printf("\nThe node ids of the partition 1 are "); for (int i = 0; i < count0; i++) { if (i > 0) printf(", "); printf("%d", part0_nodes[i]); } } printf("\n"); init_edge_counts(); double cut_cost = compute_cut_cost(); // 处理浮点数精度问题 if (fabs(cut_cost - round(cut_cost)) < 1e-6) { printf("The total cut cost is %d\n", (int)round(cut_cost)); } else { printf("The total cut cost is %.1f\n", cut_cost); } free(part0_nodes); free(part1_nodes); } int main() { printf("Please enter the number of nodes: "); scanf("%d", &n); nodes = (Node*)malloc(n * sizeof(Node)); part = (int*)malloc(n * sizeof(int)); locked = (int*)malloc(n * sizeof(int)); gain = (double*)malloc(n * sizeof(double)); node_edges = (EdgeList**)malloc(n * sizeof(EdgeList*)); for (int i = 0; i < n; i++) node_edges[i] = NULL; printf("Please enter each of the %d nodes with its id and the node area:\n", n); total_area = 0; amax = 0; for (int i = 0; i < n; i++) { int id, area; scanf("%d %d", &id, &area); nodes[i].id = id; nodes[i].area = area; total_area += area; if (area > amax) amax = area; } printf("Please enter the number of edges: "); scanf("%d", &m); edges = (HyperEdge*)malloc(m * sizeof(HyperEdge)); for (int i = 0; i < m; i++) { int k; scanf("%d", &k); edges[i].num_nodes = k; edges[i].nodes = (int*)malloc(k * sizeof(int)); for (int j = 0; j < k; j++) { int node_id; scanf("%d", &node_id); edges[i].nodes[j] = node_id; add_edge_to_node(node_id, i); } double cost; scanf("%lf", &cost); edges[i].cost = cost; } printf("Please enter the percentage of the ratio factor: "); double percent; scanf("%lf", &percent); ratio_factor = percent / 100.0; initial_partition(); fm(); output_partition(); // 清理内存 for (int i = 0; i < m; i++) free(edges[i].nodes); free(edges); for (int i = 0; i < n; i++) { EdgeList* cur = node_edges[i]; while (cur != NULL) { EdgeList* temp = cur; cur = cur->next; free(temp); } } free(node_edges); free(nodes); free(part); free(locked); free(gain); return 0; }
07-08
int heap_size; int* heap_node_id; double* heap_gain; int compare_int(const void* a, const void* b) { return (*(int*)a - *(int*)b); } void add_edge_to_node(int node_id, int edge_id) { EdgeList* new...
# # There is insufficient memory for the Java Runtime Environment to continue. # Native memory allocation (malloc) failed to allocate 731536 bytes for Chunk::new # Possible reasons: # The system is out of physical RAM or swap space # The process is running with CompressedOops enabled, and the Java Heap may be blocking the growth of the native heap # Possible solutions: # Reduce memory load on the system # Increase physical memory or swap space # Check if swap backing store is full # Decrease Java heap size (-Xmx/-Xms) # Decrease number of Java threads # Decrease Java thread stack sizes (-Xss) # Set larger code cache with -XX:ReservedCodeCacheSize= # JVM is running with Zero Based Compressed Oops mode in which the Java heap is # placed in the first 32GB address space. The Java Heap base address is the # maximum limit for the native heap growth. Please use -XX:HeapBaseMinAddress # to set the Java Heap base and to place the Java Heap above 32GB virtual addr
05-07
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/dump.hprof ``` - **分析工具**： - 使用 `jvisualvm`（JDK自带）或Eclipse Memory Analyzer（MAT）分析 `dump.hprof`。 - 查找占用内存最大的...
CVE-2016-10190 FFmpeg Heap Overflow 漏洞分析
CD的博客
08-06 1731
0x01 漏洞分析 简单来说，是因为变量在传递过程中的类型不一致，导致了传入的负数被转化为极大数，最终导致了堆溢出漏洞。 在溢出的buffer的高地址处，刚好有可利用的对象，其中的函数指针可以被覆盖。如此，就可以在后续调用这个函数指针的时候成功劫持程序的控制流。 1.1 正常情况下的程序功能 ffmpeg的-i选项可以从指定的输入流获取视频，并保存为AVI格式。下面是一个正常使用的例子...
JVM启动参数大全
混在中关村
11-09 351
jdk1.4.2 JVM官方地址：http://java.sun.com/j2se/1.4.2/docs/guide/vm/index.html 标准和非标注参数(for windows)：http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/java.html 非stable参数：http://java.sun.com/javase/te...
java.lang.OutOfMemoryError: Java heap space错误及处理办法(收集整理、转)
jxzxm1_2的专栏
05-31 47万+
以下是从网上找到的关于堆空间溢出的错误解决办法：java.lang.OutOfMemoryError: Java heap space ===================================================使用Java程序从数据库中查询大量的数据时出现异常:java.lang.OutOfMemoryError: Java heap space在JVM中如果9
mycat 启动失败 The specified size exceeds the maximum representable size
qq_42231355的博客
10-17 2908
在linux中安装mycat发现执行./mycat start命令后，不会报错，但是查看端口后，端口也并没有相应的启动监听； 操作系统:centos 6.4 jdk:7.0 mycat:1.6正式版 在mycat的bin目录下./mycat console 输出日志结果如下 解决方法：切换至mycat的conf目录，编辑wrapper.conf 修改为 wrapper.java...
JVM启动参数详解（含调优）
mrleeapple的专栏
10-25 1万+
java启动参数共分为三类； 其一是标准参数（-），所有的JVM实现都必须实现这些参数的功能，而且向后兼容； 其二是非标准参数（-X），默认jvm实现这些参数的功能，但是并不保证所有jvm实现都满足，且不保证向后兼容； 其三是非Stable参数（-XX），此类参数各个jvm实现会有所不同，将来可能会随时取消，需要慎重使用； 本文主要描述标准参数部分，剩下的两个部分将会陆续推出； 标准
JVM HeapSize Permsize
llwme的博客
03-30 1130
1: heap size  a: -Xmx  指定 jvm 的最大 heap 大小 , 如 :-Xmx=2g  b: -Xms  指定 jvm 的最小 heap 大小 , 如 :-Xms=2g ， 高并发应用， 建议和-Xmx一样， 防止因为内存收缩／突然增大带来的性能影响。  c: -Xmn  指定 jvm 中 New Generation 的大小 , 如 :-Xmn256m
lenz0a89.gsd Lenze E84AYCPM gsd
最新发布
12-05
lenz0a89.gsd Lenze E84AYCPM gsd
【大厂+2025】500+真题考点合规备考双通！.zip
12-05
【大厂+2025】500+真题考点合规备考双通！.zip
【微服务架构】基于Spring Cloud Alibaba的秒杀系统设计：高并发场景下库存超卖与分布式事务解决方案
12-05
内容概要：本文详细介绍了“秒杀商城”微服务架构的设计与实战全过程，涵盖系统从需求分析、服务拆分、技术选型到核心功能开发、分布式事务处理、容器化部署及监控链路追踪的完整流程。重点解决了高并发场景下的超卖问题，采用Redis预减库存、消息队列削峰、数据库乐观锁等手段保障数据一致性，并通过Nacos实现服务注册发现与配置管理，利用Seata处理跨服务分布式事务，结合RabbitMQ实现异步下单，提升系统吞吐能力。同时，项目支持Docker Compose快速部署和Kubernetes生产级编排，集成Sleuth+Zipkin链路追踪与Prometheus+Grafana监控体系，构建可观测性强的微服务系统。; 适合人群：具备Java基础和Spring Boot开发经验，熟悉微服务基本概念的中高级研发人员，尤其是希望深入理解高并发系统设计、分布式事务、服务治理等核心技术的开发者；适合工作2-5年、有志于转型微服务或提升架构能力的工程师； 使用场景及目标：①学习如何基于Spring Cloud Alibaba构建完整的微服务项目；②掌握秒杀场景下高并发、超卖控制、异步化、削峰填谷等关键技术方案；③实践分布式事务（Seata）、服务熔断降级、链路追踪、统一配置中心等企业级中间件的应用；④完成从本地开发到容器化部署的全流程落地； 阅读建议：建议按照文档提供的七个阶段循序渐进地动手实践，重点关注秒杀流程设计、服务间通信机制、分布式事务实现和系统性能优化部分，结合代码调试与监控工具深入理解各组件协作原理，真正掌握高并发微服务系统的构建能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值