Windows下Java进程内存分配问题汇总-Java文档类

4星 · 超过85%的资源需积分: 9 32 浏览量更新于2023-05-30 评论 5 收藏 42KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源评论

资源推荐

Windows Java address space

This article applies to the IBM 32-bit SDK and Runtime Environment for

Windows, Java2 Technology Edition. It explains how the process space

for Java is divided and explores a way of increasing the available space.

How is the space in a basic Win32 process allocated ?

A 32-bit architecture imposes a fundamental limit on an address range

of 4 GB. Hence, on a 32-bit platform any given process can theoretically

achieve a maximum size of 4 GB.

Unfortunately, on Win-32, the process space available to an application

is only 2 GB. Why is this ?

When the NT kernel was being designed, it was decided to conceptually

split the process space into two. One half for the application and one

half for use by the OS. At the time 2 GB must have seemed far more

space than anyone could possibly use. This split had certain

advantages, in that the internal address tables used by NT only needed

to be 31 bits wide.

Inside this 2 GB space, the process code and its memory requirements

are loaded at the ‘bottom’ of the space. (For the purpose of this article

we will refer to virtual address 0x00000000 as the ‘bottom’ of the

process space and address 0x7FFFFFFF as the ‘top’ of the space.)

Every application has at least one thread. A thread has an associated

stack, which is storage space allocated on its behalf from the process

space. In addition, most applications will use dynamic memory space,

either explicitly by calls such as ‘malloc’ and ‘free’, or implicitly for

example by the C++ ‘new’ operator. Stack and dynamic memory

storage is managed by Windows by means of a ‘heap’. The heap is

usually loaded above the application code and grows upwards.

When linking your application, you need to link in certain OS libraries. A

Java process loads a large number of Java libraries - the JVM

executable is very small, most of the VM comprises Dynamic Link

Libraries (DLLs). In addition, most applications link in application

libraries. For the purposes of this article, we consider application native

code libraries to be part of the application; they are loaded at addresses

determined by the application. In the case of the VM, the VM link

Java Virtual Machine

The virtual machine (VM) is the mechanism for executing the byte codes

in your java application. It is just a C application.

Java heap

The Java heap is where the VM stores Java objects. It should not be

confused with the standard Windows heap space we already alluded to.

A Java process therefore has two heaps. To distinguish them we refer

to the ‘Java heap’ and the ‘native heap’. The Java heap is a single

contiguous chunk of memory. It is a single malloc’d chunk of memory

which is never freed and is internally managed by the VM storage

component, the Garbage Collector.

The Java heap is allocated as a single chunk of memory whose size is

specified by the -Xmx command line parameter. If you don’t specify

Xmx it takes a default value of half of available physical memory up to a

maximum of (2 GB - 1) bytes. It is allocated as virtual memory. The

amount of physical memory initially committed to the heap is specified

by the -Xms parameter. As with Xmx, this parameter takes a default if

not specified.

Tip ! Specify the max heap size you want with -Xmx. Specify Xms

as a low value

. These settings allow the Java process to start

with the minimum amount of physical memory and, as the heap

grows, the Garbage Collector can optimise it. It is rarely a

good idea to specify a large value for Xms.

JIT compiled code

A Java process interpreting Java byte codes cannot approach the

performance of compiled code. A VM has a bundled compiler that

compiles Java byte codes into true platform code. Because the

compiler is invoked at runtime and compiles the code ‘just in time’ to

execute, it is known as a Just-In-Time compiler or more commonly by its

initials as a JIT compiler. In fact, we usually just refer to the JIT

compiler as ‘the JIT’ and to JIT-compiled code as ‘JIT’d code’.

It is important to note that the JIT does NOT compile Java byte codes

the first time those byte codes are executed. If it did this, then the VM

would take a very long time to start up, as thousands of methods were

剩余10页未读，继续阅读

zww519

2013-12-03

很详细，就是看的比较费劲

屌丝哥

粉丝: 4
资源: 11

会员权益专享

Windows下Java进程内存分配问题汇总

评论4

会员权益专享

最新资源

Windows下Java进程内存分配问题汇总

评论4

java内存分配方式

详细介绍Java的内存管理与内存泄露

Java进程内存有哪些组成

java内存问题怎么定位

java在编译时进行内存分配吗，都做些什么，分配空间吗

linux 查看java进程

inux下查看java进程下线程占用cpu情况

讲一下java内存分配和回收过程

如何排查linux中JAVA程序内存使用情况

java中声明与分配内存

linux关闭java进程

如何排除Java进程CPU占用高的问题

如何查看java内存占用

java在linux内存占用过高

用shell写一个java进程监控脚本

java进程的创建和控制实验

Java内存泄露的问题调查定位：jmap，jstack的使用等等

Java进程并发读取文件CPU占用高

Java程序内存占用高

会员权益专享

最新资源