目录
问题描述
JIT 即时编译器
分层编译
CodeCache 相关参数
CodeCache 满了的情况
源码介绍
作者：@dwtfukgv
本文为作者原创，转载请注明出处：https://www.cnblogs.com/dwtfukgv/p/14766317.html
问题描述
一个应用程序一直正常运行，突然某个时刻处理能力下降，但是从流量、jstack、gc上来看都是比较正常的。
会在JVM日志中出现以下日志：
Java HotSpot(TM) 64-Bit Server VM warning: CodeCache is full. Compiler has been disabled.
Java HotSpot(TM) 64-Bit Server VM warning: Try increasing the code cache size using -XX:ReservedCodeCacheSize=.
...
“CompilerThread0” java.lang.OutOfMemoryError: requested 2854248 bytes for Chunk::new. Out of swap space?这说明Code Cache已经满了。会导致这个时候JIT就会停止，JIT一旦停止，就不会再起来了，如果很多代码没有办法去JIT的话，性能就会比较差。
可能通过以下命令来查看JVM的参数值:
jinfo -flag <param> <PID>可以查看Code Cache的最大值是多少：
jinfo -flag ReservedCodeCacheSize <PID>JIT 即时编译器
JIT（Just In Time Compiler）编译器（分Client端和Server端）。Java程序一开始是只是通过解释器解释执行的，即对字节码逐条解释执行，这样执行速度会比较慢，尤其是当某个方法或者代码块运行的特别频繁时。后来就有了JIT即时编译器，当虚拟机发现某个方法或代码块运行特别频繁时，就为了提高代码执行效率，JIT会把这些代码编译成与本地平台相关的机器码，下一次执行就会直接执行编译后的机器码，并进行各个层次的优化。这样的代码一般包括两类：一类是频繁调用的方法，另一个类是多次执行的循环体。
经过JIT编译后的代码被缓存的内存区域就是CodeCache，这是一块独立于java堆之外的内存区域，并且java的本地方法代码JNI也存储在该区域。
分层编译
JVM提供了一个参数-Xcomp，可以使JVM运行在纯编译模式下，所有方法在第一次被调用的时候就会被编译成机器代码。加上这个参数之后，应用的启动时间会变得的特别长。
除了纯编译方式和默认的mixed之外，从JDK6u25开始引入了一种分层编译的方式。
Hotspot JVM内置了2种编译器，分别是 client方式启动时用的C1编译器和 server方式启动时用的C2编译器 。
C2编译器在将代码编译成机器码之前，需要收集大量的统计信息以便在编译的时候做优化，因此编译后的代码执行效率也高，代价是程序启动速度慢，并且需要比较长的执行时间才能达到最高性能。
C1编译器的目标在于使程序尽快进入编译执行阶段，因此编译前需要收集的统计信息比C2少很多，编译速度也快不少。代价是编译出的目标代码比C2编译的执行效率要低，但是这也要比解释执行快很多。
分层编译方式是一种折衷方式，在系统启动之初执行频率比较高的代码将先被C1编译器编译，以便尽快进入编译执行。随着时间推进，一些执行频率高的代码会被C2编译器再次编译，从而达到更高的性能。
可以通过-XX:+TieredCompilation来开启分层编译。
在JDK8中，当以server模式启动时，分层编译默认开启。需要注意的是，分层编译方式只能用于server模式中，如果需要关闭分层编译，需要加上启动参数 -XX:-TieredCompilation。
CodeCache 相关参数
CodeCache的内存大小相关参数：
-XX:InitialCodeCacheSize # 用于设置初始CodeCache大小
-XX:ReservedCodeCacheSize # 用于设置CodeCache的最大大小，通常默认是240M
-XX:CodeCacheExpansionSize # 用于设置CodeCache的扩展大小，通常默认是64KCodeCache刷新相关参数：
-XX:CompileThreshold # 方法触发编译时的调用次数，默认是10000
-XX:OnStackReplacePercentage # 方法中循环执行部分代码的执行次数触发OSR编译时的阈值，默认是140CodeCache编译策略相关参数：
-XX:CompileThreshold # 方法触发编译时的调用次数，默认是10000-XX:OnStackReplacePercentage # 方法中循环执行部分代码的执行次数触发OSR编译时的阈值，默认是140CodeCache编译限制相关参数：
-XX:MaxInlineLevel # 针对嵌套调用的最大内联深度，默认为9
-XX:MaxInlineSize # 方法可以被内联的最大bytecode大小，默认为35
-XX:MinInliningThreshold # 方法可以被内联的最小调用次数，默认为250
-XX:+InlineSynchronizedMethods # 是否允许内联synchronized methods，默认为trueCodeCache输出参数的相关参数：
-XX:+PrintCodeCache # 在JVM停止的时候打印出codeCache的使用情况，其中max_used就是在整个运行过程中codeCache的最大使用量
-XX:+PrintCodeCacheOnCompilation # 用于在方法每次被编译时输出CodeCache的使用情况CodeCache 满了的情况
当CodeCache满了，会出现的情况：
如果未开启-XX:+UseCodeCacheFlushing，JIT编译器被停止了，并且不会被重新启动，此时会回归到解释执行，被编译过的代码仍然以编译方式执行，但是尚未被编译的代码就只能以解释方式执行了。
如果未开启-XX:+UseCodeCacheFlushing，最早被编译的一半方法将会被放到一个old列表中等待回收，在一定时间间隔内，如果old列表中方法没有被调用，这个方法就会被从CodeCache清除。
开启-XX:+UseCodeCacheFlushing可能会导致的问题：
CodeCache满了时紧急进行清扫工作，它会丢弃一半老的编译代码
CodeCache空间降了一半，方法编译工作仍然可能不会重启
flushing可能导致高的CPU使用，从而影响性能下降
源码介绍
CodeCache就是用于缓存不同类型的生成的汇编代码，如热点方法编译后的代码。所有的汇编代码在CodeCache中都是以CodeBlob及其子类的形式存在的。
class CodeCache : AllStatic {
friend class VMStructs;
private:
static CodeHeap * _heap; // 实际负责内存管理
// 各种类型的计数
static int _number_of_blobs;
static int _number_of_adapters;
static int _number_of_nmethods;
static int _number_of_nmethods_with_dependencies;
static bool _needs_cache_clean;
static nmethod* _scavenge_root_nmethods; // gc时遍历nmethod
public:
static void initialize(); // 初始化，像上面的参数，都是在这里面初始化
static void report_codemem_full(); // 报告内存满了
static CodeBlob* allocate(int size, bool is_critical = false); // 申请内存
static void commit(CodeBlob* cb); // 当codeblob满了时会调用该方法
static void free(CodeBlob* cb); // 释放CodeBlob
}
CodeCache只是CodeHeap的一层包装而已，核心实现都在CodeHeap中。
CodeHeap就是实际管理汇编代码内存分配的实现，在HotSpot VM中，除了模板解释器外，有很多地方也会用到运行时机器代码生成技术，如的C1编译器产出、C2编译器产出、C2I/I2C适配器代码片段、解释器到JNI适配器的代码片段等。为了统一管理这些运行时生成的机器代码，HotSpot VM抽象出一个CodeBlob体系，由CodeBlob作为基类表示所有运行时生成的机器代码：
class CodeHeap : public CHeapObj<mtCode> {
friend class VMStructs;
private:
VirtualSpace _memory; // 用于描述CodeHeap对应的一段连续的内存空间 block
VirtualSpace _segmap; // 用于保存所有的segment的起始地址，记录这些segment的使用情况
size_t _number_of_committed_segments; // 已分配内存的segments的数量
size_t _number_of_reserved_segments; // 剩余的未分配内存的保留的segments的数量
size_t _segment_size; // 一个segment的大小 -XX:CodeCacheSegmentSize每次扩展的大小
int _log2_segment_size; // segment的大小取log2，用于计算根据内存地址计算所属的segment的序号
size_t _next_segment; // 下一待分配给Block的segment的序号
// 一个segment可以理解为一个内存页，是操作系统分配内存的最小粒度，为了避免内存碎片，任意一个Block的大小都必须是segment的整数倍，即任意一个Block会对应N个segment。
FreeBlock* _freelist; // 可用的HeapBlock 链表，所有的Block按照地址依次增加的顺序排序，即_freelist是内存地址最小的一个Block
size_t _freelist_segments; // 可用的segments的个数，也就是freeLists的长度
// Helper functions
size_t size_to_segments(size_t size) const { return (size + _segment_size - 1) >> _log2_segment_size; } // 计算size包含多少个segment
size_t segments_to_size(size_t number_of_segments) const { return number_of_segments << _log2_segment_size; } //
size_t segment_for(void* p) const { return ((char*)p - _memory.low()) >> _log2_segment_size; } // 地址p在第几个segment
HeapBlock* block_at(size_t i) const { return (HeapBlock*)(_memory.low() + (i << _log2_segment_size)); } // 第i个heapblock块地址
void mark_segmap_as_free(size_t beg, size_t end); // 标记为未分配给Block
void mark_segmap_as_used(size_t beg, size_t end); // 记为已分配给Block
// Linux的内存映射相关操作
void on_code_mapping(char* base, size_t size);
public:
CodeHeap();
// 方法主要是对codeHeap中定义的_memory与_segmap属性进行初始化，CodeCache初始化时调用此方法
// -XX:ReservedCodeCacheSize：设置代码缓存的大小
// -XX:InitialCodeCacheSize：设置代码缓存的初始大小，
// -XX:CodeCacheSegmentSize：每次存储请求都会分配一定大小的空间
bool reserve(size_t reserved_size, size_t committed_size, size_t segment_size);
void release(); // 释放所有
bool expand_by(size_t size); // 扩展 commited
void shrink_by(size_t size); // 收缩 commited memory
void clear(); // 清空所有
// Memory allocation
void* allocate (size_t size, bool is_critical); // 申请一个size大小的block
void deallocate(void* p); // 释放
// Attributes
char* low_boundary() const { return _memory.low_boundary (); }
char* high() const { return _memory.high(); }
char* high_boundary() const { return _memory.high_boundary(); }
};VirtualSpace是与ReservedSpace配合使用的，ReservedSpace是预先分配一段连续的内存空间，VirtualSpace负责在这段内存空间内实际申请内存。
// VirtualSpace是与ReservedSpace配合使用的，ReservedSpace是预先分配一段连续的内存空间，VirtualSpace负责在这段内存空间内实际申请内存。
class VirtualSpace VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
private:
// Reserved area 通过ReservedSpace分配的地址空间范围
char* _low_boundary;
char* _high_boundary;
// Committed area 通过VirtualSpace实际申请并使用的内存区域
char* _low;
char* _high;
// os::commit_memory() or os::uncommit_memory().
bool _special;
//
bool _executable;
// 中间分配给大内存页，两边默认内存页
char* _lower_high;
char* _middle_high;
char* _upper_high;
char* _lower_high_boundary;
char* _middle_high_boundary;
char* _upper_high_boundary;
size_t _lower_alignment;
size_t _middle_alignment;
size_t _upper_alignment;
public:
VirtualSpace(); // 初始化
bool initialize_with_granularity(ReservedSpace rs, size_t committed_byte_size, size_t max_commit_ganularity);
bool initialize(ReservedSpace rs, size_t committed_byte_size);
size_t reserved_size() const;
size_t actual_committed_size() const;
// 使用的
size_t committed_size() const;
// 未使用的
size_t uncommitted_size() const;
bool contains(const void* p) const;
bool expand_by(size_t bytes, bool pre_touch = false);
void shrink_by(size_t bytes);
void release();
}ReservedSpace用来分配一段地址连续的内存空间，底层通过mmap实现，注意此时未实际分配内存。
// ReservedSpace用来分配一段地址连续的内存空间，底层通过mmap实现，注意此时未实际分配内存
class ReservedSpace VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
private:
char* _base; // 这段连续内存空间的基地址
size_t _size; // 内存大小
size_t _noaccess_prefix;
size_t _alignment;
bool _special; // 是否走特殊方法分配
bool _executable; // 这段内存存储的数据是否是可执行的
// ReservedSpace
ReservedSpace(char* base, size_t size, size_t alignment, bool special,
bool executable);
void initialize(size_t size, size_t alignment, bool large,
char* requested_address,
const size_t noaccess_prefix,
bool executable);
}VirtualSpace中每个指针的含义如下图：
CodeBlob的继承关系与子类的作用如下图：
扫一扫
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
