if (native_thread->osthread() == NULL) {
  // 线程创建失败，直接抛出 OutOfMemoryError，不调用 report_java_out_of_memory
  THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
            os::native_thread_creation_failed_msg());
}

// Unicode 字符串分配失败，直接抛出 OutOfMemoryError
THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string");

// 类验证过程中内存不足，直接抛出 OutOfMemoryError
THROW_MSG_(vmSymbols::java_lang_OutOfMemoryError(), message, NULL);

u1* class_bytes = NEW_C_HEAP_ARRAY(u1, length, mtInternal);
if (class_bytes == NULL) {
  // Unsafe 操作中内存分配失败，直接抛出 OutOfMemoryError
  THROW_0(vmSymbols::java_lang_OutOfMemoryError());
}

if (blob == NULL) {
  // CodeCache 内存不足，直接退出 VM，不抛出异常
  vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "CodeCache: no room for method handle adapter blob");
}

bool MemAllocator::Allocation::check_out_of_memory() {
  // ... 省略分配失败检查 ...
  
  if (!_overhead_limit_exceeded) {
    // Java 对象堆空间不足，调用 report_java_out_of_memory 触发 Heap Dump
    report_java_out_of_memory("Java heap space");
    // ... 省略 JVMTI 相关代码 ...
    THROW_OOP_(Universe::out_of_memory_error_java_heap(), true);
  } else {
    // GC 开销超限，调用 report_java_out_of_memory 触发 Heap Dump
    report_java_out_of_memory("GC overhead limit exceeded");
    // ... 省略 JVMTI 相关代码 ...
    THROW_OOP_(Universe::out_of_memory_error_gc_overhead_limit(), true);
  }
}

bool MemAllocator::Allocation::check_out_of_memory() {
  // ... 省略分配失败检查 ...
  
  const char* message = _overhead_limit_exceeded ? 
    "GC overhead limit exceeded" : "Java heap space";
  
  // JDK 17+ 新增可重试分配检查，避免在可重试场景触发 Heap Dump
  if (!_thread->in_retryable_allocation()) {  // JDK 17-21
  // if (!_thread->is_in_internal_oome_mark()) {  // JDK 25+
    report_java_out_of_memory(message);
    // ... 省略 JVMTI 相关代码 ...
    THROW_OOP_(exception, true);
  } else {
    // 可重试分配失败，抛出 retry OOM（不触发 Heap Dump）
    THROW_OOP_(Universe::out_of_memory_error_retry(), true);  // JDK 17-21
    // THROW_OOP_(Universe::out_of_memory_error_java_heap_without_backtrace(), true);  // JDK 25+
  }
}

// RAII 类，用于标记线程处于内部 OOM 处理场景
// 在这些场景中，OOM 不会传播到用户代码，因此不需要堆栈跟踪
class InternalOOMEMark: public StackObj {
  explicit InternalOOMEMark(JavaThread* thread) {
    _outer = thread->is_in_internal_oome_mark();
    thread->set_is_in_internal_oome_mark(true);  // 设置标记
    _thread = thread;
  }
  
  ~InternalOOMEMark() {
    _thread->set_is_in_internal_oome_mark(_outer);  // 恢复标记
  }
};

// 反优化时重新分配对象，使用 InternalOOMEMark 标记
if (obj == nullptr && !cache_init_error) {
  InternalOOMEMark iom(THREAD);  // 进入内部 OOM 标记场景
  obj = ik->allocate_instance(THREAD);  // 如果失败，抛出无堆栈跟踪的 OOM
}

void Metaspace::allocate(ClassLoaderData* cld, size_t word_size, 
                         bool read_only, MetaspaceObj::Type type, 
                         Metaspace** result, TRAPS) {
  // ... 省略元空间分配逻辑 ...
  
  // 元空间或压缩类空间耗尽，调用 report_java_out_of_memory 触发 Heap Dump
  // 合理性：加载的类在 Java 对象堆上有 Class 对象，Heap Dump 有助于分析类加载问题
  const char* space_string = out_of_compressed_class_space ?
    "Compressed class space" : "Metaspace";
  report_java_out_of_memory(space_string);
  // ... 省略异常抛出 ...
}

typeArrayOop TypeArrayKlass::allocate(int length, TRAPS) {
  // ... 省略数组分配逻辑 ...
  
  if (length > max_length()) {
    // 数组大小超过 VM 限制，调用 report_java_out_of_memory 触发 Heap Dump
    // 合理性：通常表示集合过大，可能存在内存泄漏
    report_java_out_of_memory("Requested array size exceeds VM limit");
    JvmtiExport::post_array_size_exhausted();
    THROW_OOP_0(Universe::out_of_memory_error_array_size());
  }
}

void Klass::check_array_allocation_length(int length, int max_length, TRAPS) {
  if (length > max_length) {
    // JDK 17+ 新增可重试分配检查
    if (!THREAD->in_retryable_allocation()) {
      report_java_out_of_memory("Requested array size exceeds VM limit");
      JvmtiExport::post_array_size_exhausted();
      THROW_OOP(Universe::out_of_memory_error_array_size());
    } else {
      // 可重试分配失败，抛出 retry OOM（不触发 Heap Dump）
      THROW_OOP(Universe::out_of_memory_error_retry());
    }
  }
}

void report_java_out_of_memory(const char* message) {
  static int out_of_memory_reported = 0;

  // 多个线程可能同时尝试报告 OutOfMemoryError，使用原子操作确保只执行一次
  // JDK 11: Atomic::cmpxchg(expected, addr, new_value) 返回旧值
  if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
    // 在 OnOutOfMemoryError 命令执行之前创建 Java 对象堆转储
    if (HeapDumpOnOutOfMemoryError) {
      tty->print_cr("java.lang.OutOfMemoryError: %s", message);
      HeapDumper::dump_heap_from_oome();
    }

    // ... 省略 OnOutOfMemoryError 处理 ...
    
    if (CrashOnOutOfMemoryError) {
      fatal("OutOfMemory encountered: %s", message);
    }

    if (ExitOnOutOfMemoryError) {
      os::exit(3);
    }
  }
}

void report_java_out_of_memory(const char* message) {
  static int out_of_memory_reported = 0;

  // JDK 17+: Atomic::cmpxchg(addr, expected, new_value) 参数顺序变化
  if (Atomic::cmpxchg(&out_of_memory_reported, 0, 1) == 0) {
    if (HeapDumpOnOutOfMemoryError) {
      tty->print_cr("java.lang.OutOfMemoryError: %s", message);
      HeapDumper::dump_heap_from_oome();
    }

    // ... 省略 OnOutOfMemoryError 处理 ...
    
    if (CrashOnOutOfMemoryError) {
      // JDK 17+: 使用 report_fatal 替代 fatal
      report_fatal(OOM_JAVA_HEAP_FATAL, __FILE__, __LINE__, "OutOfMemory encountered: %s", message);
    }

    if (ExitOnOutOfMemoryError) {
      os::exit(3);  // JDK 17
      // os::_exit(3);  // JDK 21+: 快速退出，不运行清理钩子
    }
  }
}

// 由 OOM 错误报告调用，在 Java 线程中，不在安全点
void HeapDumper::dump_heap_from_oome() {
  HeapDumper::dump_heap(true);
}

// 由错误报告调用（不在安全点）或由 VM 线程在 GC 安全点调用
void HeapDumper::dump(const char* path) {
  // ... 省略 writer 创建等代码 ...
  
  // 创建 VM_HeapDumper 操作对象
  VM_HeapDumper dumper(&writer, _gc_before_heap_dump, _oome);
  
  if (Thread::current()->is_VM_thread()) {
    // 如果已经是 VM 线程，必须在安全点
    assert(SafepointSynchronize::is_at_safepoint(), "Expected to be called at a safepoint");
    dumper.doit();
  } else {
    // 否则通过 VMThread::execute 触发安全点，所有 Java 线程暂停
    VMThread::execute(&dumper);
  }
  // ... 省略其他代码 ...
}

void HeapDumper::dump_heap(bool oome) {
  static char base_path[JVM_MAXPATHLEN] = {'\0'};
  static uint dump_file_seq = 0;
  char* my_path;
  
  const char* dump_file_name = "java_pid";
  const char* dump_file_ext  = ".hprof";

  if (dump_file_seq == 0) {
    // 首次调用：处理 HeapDumpPath，构建基础路径
    // ... 省略路径验证和目录检查 ...
    
    // 如果未指定 HeapDumpPath 或为目录，使用默认文件名
    if (use_default_filename) {
      jio_snprintf(&base_path[dlen], sizeof(base_path)-dlen, "%s%d%s",
                   dump_file_name, os::current_process_id(), dump_file_ext);
    }
    
    // JDK 11-21: 使用 os::malloc 从原生堆分配路径内存
    my_path = (char*)os::malloc(len, mtInternal);
    if (my_path == NULL) {
      warning("Cannot create heap dump file.  Out of system memory.");
      return;
    }
    strncpy(my_path, base_path, len);
  } else {
    // 后续转储：追加序列号
    jio_snprintf(my_path, len, "%s.%d", base_path, dump_file_seq);
  }
  dump_file_seq++;

  // 创建 HeapDumper 对象并执行转储（不支持压缩）
  HeapDumper dumper(false, true, oome);
  dumper.dump(my_path);
  os::free(my_path);
}

void HeapDumper::dump_heap(bool oome) {
  // ... 省略路径处理逻辑（类似 JDK 11） ...
  
  // JDK 17+: 根据 HeapDumpGzipLevel 决定文件扩展名
  const char* dump_file_ext = (HeapDumpGzipLevel > 0) ? ".hprof.gz" : ".hprof";
  
  // ... 省略路径构建 ...
  
  // 创建 HeapDumper 对象，支持压缩
  HeapDumper dumper(false, true, oome);
  dumper.dump(my_path);
  os::free(my_path);
}

void HeapDumper::dump_heap(bool oome) {
  static char base_path[JVM_MAXPATHLEN] = {'\0'};
  static uint dump_file_seq = 0;
  
  // JDK 25+: 使用栈上分配，避免在 OOM 场景下分配失败
  char my_path[JVM_MAXPATHLEN];
  
  if (dump_file_seq == 0) {
    // JDK 25+: 支持 %p 占位符，使用 Arguments::copy_expand_pid 展开
    if (HeapDumpPath != nullptr && strstr(HeapDumpPath, "%p") != nullptr) {
      Arguments::copy_expand_pid(HeapDumpPath, my_path, JVM_MAXPATHLEN);
    }
    // ... 省略其他路径处理 ...
  }
  
  // JDK 25+: 支持并行转储和压缩
  HeapDumper dumper(false, true, oome);
  dumper.dump(my_path);
}

// 默认线程数：CPU 核心数的 3/8
static uint default_num_of_dump_threads() {
  return MAX2<uint>(1, (uint)os::initial_active_processor_count() * 3 / 8);
}

int HeapDumper::dump(const char* path, outputStream* out, int compression, bool overwrite, uint num_dump_threads) {
  // OOM 场景下的线程数限制：每个线程需要约 20MB 内存
  if (_oome && num_dump_threads > 1) {
    // DumpWriter buffer, DumperClassCacheTable, GZipCompressor buffers
    julong max_threads = os::free_memory() / (20 * M);
    if (num_dump_threads > max_threads) {
      num_dump_threads = MAX2<uint>(1, (uint)max_threads);
    }
  }
  // ... 省略其他代码 ...
}

void VM_HeapDumper::prepare_parallel_dump(WorkerThreads* workers) {
  uint num_active_workers = workers != nullptr ? workers->active_workers() : 0;
  uint num_requested_dump_threads = _num_dumper_threads;
  
  // 检查是否可以并行转储
  if (num_active_workers <= 1 || num_requested_dump_threads <= 1) {
    _num_dumper_threads = 1;  // 单线程转储
  } else {
    // 限制在 2 到 active_workers 之间
    _num_dumper_threads = clamp(num_requested_dump_threads, 2U, num_active_workers);
  }
  
  _dumper_controller = new (std::nothrow) DumperController(_num_dumper_threads);
  // ... 记录日志 ...
}

class G1ParallelObjectIterator : public ParallelObjectIteratorImpl {
  G1HeapRegionClaimer _claimer;  // 按 region 切分
  
public:
  G1ParallelObjectIterator(uint thread_num) :
      _heap(G1CollectedHeap::heap()),
      _claimer(thread_num == 0 ? G1CollectedHeap::heap()->workers()->active_workers() : thread_num) {}
  
  virtual void object_iterate(ObjectClosure* cl, uint worker_id) {
    // 每个 worker 处理不同的 region
    _heap->object_iterate_parallel(cl, worker_id, &_claimer);
  }
};

void VM_HeapDumper::doit() {
  CollectedHeap* ch = Universe::heap();
  
  // 可选：转储前执行 GC
  if (_gc_before_heap_dump) {
    ch->collect_as_vm_thread(GCCause::_heap_dump);
  }
  
  WorkerThreads* workers = ch->safepoint_workers();
  prepare_parallel_dump(workers);  // 确定实际线程数
  
  if (!is_parallel_dump()) {
    // 单线程转储
    work(VMDumperId);
  } else {
    // 并行转储：创建 ParallelObjectIterator 并启动多个 worker
    ParallelObjectIterator poi(_num_dumper_threads);
    _poi = &poi;
    workers->run_task(this, _num_dumper_threads);  // 启动 worker 线程
    _poi = nullptr;
  }
}

void VM_HeapDumper::work(uint worker_id) {
  int dumper_id = get_next_dumper_id();  // 原子获取 dumper ID
  
  if (is_vm_dumper(dumper_id)) {
    // VM Dumper (worker_id=0)：负责非堆数据
    _dumper_controller->lock_global_writer();
    _dumper_controller->signal_start();
    
    // 写入文件头、UTF8、类加载、堆栈跟踪等
    writer()->write_raw("JAVA PROFILE 1.0.2", ...);
    SymbolTable::symbols_do(&sym_dumper);
    ClassLoaderDataGraph::classes_do(&loaded_class_dumper);
    dump_stack_traces(writer());
    
    _dumper_controller->unlock_global_writer();  // 释放锁，允许并行 dumpers 开始
  } else {
    // Parallel Dumpers (worker_id=1-N)：等待 VM Dumper 完成非堆数据
    _dumper_controller->wait_for_start_signal();
  }
  
  // 创建段文件：base_path.p0, .p1, .p2, ...
  DumpWriter segment_writer(DumpMerger::get_writer_path(writer()->get_file_path(), dumper_id),
                            writer()->is_overwrite(), writer()->compressor());
  
  if (is_vm_dumper(dumper_id)) {
    // VM Dumper 还负责写入类转储、线程对象、JNI 全局引用等
    ClassDumper class_dumper(&segment_writer);
    ClassLoaderDataGraph::classes_do(&class_dumper);
    dump_threads(&segment_writer);
    // ... 省略其他 GC root ...
  }
  
  // 并行遍历堆对象
  HeapObjectDumper obj_dumper(&segment_writer, this);
  if (!is_parallel_dump()) {
    Universe::heap()->object_iterate(&obj_dumper);
  } else {
    // 并行转储：每个 worker 遍历分配的堆区域
    _poi->object_iterate(&obj_dumper, worker_id);
  }
  
  segment_writer.finish_dump_segment();
  segment_writer.flush();
  
  _dumper_controller->dumper_complete(&segment_writer, writer());
  
  if (is_vm_dumper(dumper_id)) {
    // VM Dumper 等待所有并行 dumpers 完成
    _dumper_controller->wait_all_dumpers_complete();
    writer()->flush();
    // 此时所有段文件已写入，需要在安全点外合并
  }
}

class GZipCompressor : public AbstractCompressor {
  int _level;           // 压缩级别 0-9
  size_t _block_size;  // 压缩块大小
  bool _is_first;       // 是否为第一个块
  
public:
  virtual char const* compress(char* in, size_t in_size, char* out, size_t out_size,
                               char* tmp, size_t tmp_size, size_t* compressed_size) {
    // 每个段文件独立压缩，使用独立的压缩缓冲区
    if (_is_first) {
      // 第一个块写入块大小注释
      jio_snprintf(buf, sizeof(buf), "HPROF BLOCKSIZE=%zu", _block_size);
      *compressed_size = ZipLibrary::compress(..., buf, ...);
      _is_first = false;
    } else {
      *compressed_size = ZipLibrary::compress(..., nullptr, ...);
    }
  }
};

int HeapDumper::dump(const char* path, ...) {
  // Phase 1: 在安全点内并行写入段文件
  VM_HeapDumper dumper(&writer, _gc_before_heap_dump, _oome, num_dump_threads);
  VMThread::execute(&dumper);
  
  // Phase 2: 在安全点外合并段文件（不占用 VM Thread）
  DumpMerger merger(path, &writer, dumper.dump_seq());
  merger.do_merge();
}

void DumpMerger::do_merge() {
  // 合并时不需要再次压缩（段文件已压缩）
  AbstractCompressor* saved_compressor = _writer->compressor();
  _writer->set_compressor(nullptr);
  
  // 按顺序合并所有段文件
  for (int i = 0; i < _dump_seq; i++) {
    const char* path = get_writer_path(_path, i);  // base_path.p0, .p1, ...
    merge_file(path);
    remove(path);  // 删除临时段文件
  }
  
  _writer->set_compressor(saved_compressor);
  // 写入 HPROF_HEAP_DUMP_END 记录
  DumperSupport::end_of_dump(_writer);
}

#ifdef LINUX
void DumpMerger::merge_file(const char* path) {
  // Linux: 使用 sendfile 零拷贝合并（高效）
  int segment_fd = os::open(path, O_RDONLY, 0);
  os::Linux::sendfile(_writer->get_fd(), segment_fd, &offset, st.st_size);
  ::close(segment_fd);
}
#else
void DumpMerger::merge_file(const char* path) {
  // 其他平台: 使用 read + write 合并
  fileStream segment_fs(path, "rb");
  while ((cnt = segment_fs.read(_writer->buffer(), 1, _writer->buffer_size())) != 0) {
    _writer->set_position(cnt);
    _writer->flush();
  }
}
#endif

void CollectedHeap::full_gc_dump(GCTimer* timer, bool before) {
  assert(timer != NULL, "timer is null");
  // 检查是否启用相应的 Heap Dump 参数
  if ((HeapDumpBeforeFullGC && before) || (HeapDumpAfterFullGC && !before)) {
    // 记录 GC 日志并触发 Java 对象堆转储
    GCTraceTime(Info, gc) tm(before ? "Heap Dump (before full gc)" : "Heap Dump (after full gc)", timer);
    HeapDumper::dump_heap();
  }
  // ... 省略其他代码 ...
}

void CollectedHeap::full_gc_dump(GCTimer* timer, bool before) {
  assert(timer != nullptr, "timer is null");
  static uint count = 0;  // 静态计数器，记录已转储次数
  // 检查是否启用相应的 Heap Dump 参数
  if ((HeapDumpBeforeFullGC && before) || (HeapDumpAfterFullGC && !before)) {
    // 检查转储次数限制：0 表示无限制，否则检查是否超过限制
    if (FullGCHeapDumpLimit == 0 || count < FullGCHeapDumpLimit) {
      GCTraceTime(Info, gc) tm(before ? "Heap Dump (before full gc)" : "Heap Dump (after full gc)", timer);
      HeapDumper::dump_heap();
      count++;  // 转储后递增计数器
    }
  }
  // ... 省略其他代码 ...
}

product(ccstr, HeapDumpPath, NULL, MANAGEABLE,
        "When HeapDumpOnOutOfMemoryError is on, the path (filename or "
        "directory) of the dump file (defaults to java_pid<pid>.hprof "
        "in the current working directory)")

void HeapDumper::dump_heap(bool oome) {
  static char base_path[JVM_MAXPATHLEN] = {'\0'};
  static uint dump_file_seq = 0;
  char* my_path;
  
  const char* dump_file_name = "java_pid";
  const char* dump_file_ext  = HeapDumpGzipLevel > 0 ? ".hprof.gz" : ".hprof";
  
  if (dump_file_seq == 0) {
    // 首次调用：计算最长路径长度并验证
    const size_t total_length =
        (HeapDumpPath == NULL ? 0 : strlen(HeapDumpPath)) +
        strlen(os::file_separator()) + max_digit_chars +
        strlen(dump_file_name) + strlen(dump_file_ext) + 1;
    if (total_length > sizeof(base_path)) {
      warning("Cannot create heap dump file.  HeapDumpPath is too long.");
      return;
    }
    
    bool use_default_filename = true;
    if (HeapDumpPath == NULL || HeapDumpPath[0] == '\0') {
      // 未指定 HeapDumpPath，使用默认文件名
    } else {
      strcpy(base_path, HeapDumpPath);
      // 检查路径是否为已存在的目录
      DIR* dir = os::opendir(base_path);
      if (dir == NULL) {
        // 不是目录，视为文件名
        use_default_filename = false;
      } else {
        // 是目录，追加文件分隔符（如果需要）
        os::closedir(dir);
        size_t fs_len = strlen(os::file_separator());
        if (strlen(base_path) >= fs_len) {
          char* end = base_path;
          end += (strlen(base_path) - fs_len);
          if (strcmp(end, os::file_separator()) != 0) {
            strcat(base_path, os::file_separator());
          }
        }
      }
    }
    
    // 如果 HeapDumpPath 不是文件名，则追加默认文件名
    if (use_default_filename) {
      const size_t dlen = strlen(base_path);
      jio_snprintf(&base_path[dlen], sizeof(base_path)-dlen, "%s%d%s",
                   dump_file_name, os::current_process_id(), dump_file_ext);
    }
    
    // 使用 os::malloc 从原生堆分配路径内存
    const size_t len = strlen(base_path) + 1;
    my_path = (char*)os::malloc(len, mtInternal);
    if (my_path == NULL) {
      warning("Cannot create heap dump file.  Out of system memory.");
      return;
    }
    strncpy(my_path, base_path, len);
  } else {
    // 后续转储：追加序列号
    const size_t len = strlen(base_path) + max_digit_chars + 2; // for '.' and \0
    my_path = (char*)os::malloc(len, mtInternal);
    if (my_path == NULL) {
      warning("Cannot create heap dump file.  Out of system memory.");
      return;
    }
    jio_snprintf(my_path, len, "%s.%d", base_path, dump_file_seq);
  }
  dump_file_seq++;
  
  // ... 执行转储 ...
  os::free(my_path);
}

void HeapDumper::dump_heap(bool oome) {
  static char base_path[JVM_MAXPATHLEN] = {'\0'};
  static uint dump_file_seq = 0;
  char my_path[JVM_MAXPATHLEN];  // JDK 25+: 使用栈上分配，避免 OOM 场景分配失败
  const int max_digit_chars = 20;
  const char* dump_file_name = HeapDumpGzipLevel > 0 ? "java_pid%p.hprof.gz" : "java_pid%p.hprof";
  
  if (dump_file_seq == 0) {
    // 设置基础路径（文件名或目录，默认或自定义，不含序列号），执行 %p 替换
    const char *path_src = (HeapDumpPath != nullptr && HeapDumpPath[0] != '\0') ? HeapDumpPath : dump_file_name;
    // 使用 Arguments::copy_expand_pid 展开 %p 占位符
    if (!Arguments::copy_expand_pid(path_src, strlen(path_src), base_path, JVM_MAXPATHLEN - max_digit_chars)) {
      warning("Cannot create heap dump file.  HeapDumpPath is too long.");
      return;
    }
    
    // 检查路径是否为已存在的目录
    DIR* dir = os::opendir(base_path);
    if (dir != nullptr) {
      os::closedir(dir);
      // 路径是目录，追加文件分隔符（如果需要）
      size_t fs_len = strlen(os::file_separator());
      if (strlen(base_path) >= fs_len) {
        char* end = base_path;
        end += (strlen(base_path) - fs_len);
        if (strcmp(end, os::file_separator()) != 0) {
          strcat(base_path, os::file_separator());
        }
      }
      // 然后添加默认文件名，执行 %p 替换。使用 my_path 临时存储
      if (!Arguments::copy_expand_pid(dump_file_name, strlen(dump_file_name), my_path, JVM_MAXPATHLEN - max_digit_chars)) {
        warning("Cannot create heap dump file.  HeapDumpPath is too long.");
        return;
      }
      const size_t dlen = strlen(base_path);
      jio_snprintf(&base_path[dlen], sizeof(base_path) - dlen, "%s", my_path);
    }
    strncpy(my_path, base_path, JVM_MAXPATHLEN);
  } else {
    // 后续转储：追加序列号
    const size_t len = strlen(base_path) + max_digit_chars + 2; // for '.' and \0
    jio_snprintf(my_path, len, "%s.%d", base_path, dump_file_seq);
  }
  dump_file_seq++;
  
  // ... 执行转储 ...
}

bool Arguments::copy_expand_pid(const char* src, size_t srclen,
                                char* buf, size_t buflen) {
  const char* p = src;
  char* b = buf;
  const char* src_end = &src[srclen];
  char* buf_end = &buf[buflen - 1];
  
  while (p < src_end && b < buf_end) {
    if (*p == '%') {
      switch (*(++p)) {
      case '%':         // "%%" ==> "%"（转义）
        *b++ = *p++;
        break;
      case 'p':  {       // "%p" ==> 当前进程 ID
        // 计算可用缓冲区大小
        size_t buf_sz = buf_end - b + 1;
        // 使用 jio_snprintf 格式化进程 ID
        int ret = jio_snprintf(b, buf_sz, "%d", os::current_process_id());
        
        // 如果格式化失败或缓冲区不足，返回 false
        if (ret < 0 || ret >= (int)buf_sz) {
          return false;
        } else {
          b += ret;  // 移动缓冲区指针
          assert(*b == '\0', "fail in copy_expand_pid");
          if (p == src_end && b == buf_end + 1) {
            // 到达缓冲区末尾
            return true;
          }
        }
        p++;  // 跳过 'p'
        break;
      }
      default:
        // 未知占位符，原样复制
        *b++ = '%';
        *b++ = *p++;
        break;
      }
    } else {
      // 普通字符，直接复制
      *b++ = *p++;
    }
  }
  
  *b = '\0';  // 确保字符串以 null 结尾
  return true;
}

-XX:OnOutOfMemoryError="kill -9 %p"
-XX:OnOutOfMemoryError="/path/to/script.sh"

product(ccstrlist, OnOutOfMemoryError, "",
        "Run user-defined commands on first java.lang.OutOfMemoryError "
        "(see VMError::report_java_out_of_memory)")

# 单个命令
-XX:OnOutOfMemoryError="kill -9 %p"

# 多个命令（分号分隔）
-XX:OnOutOfMemoryError="echo OOM occurred; kill -9 %p"

# 执行脚本
-XX:OnOutOfMemoryError="/path/to/script.sh %p"

static char* next_OnError_command(char* buf, int buflen, const char** ptr) {
  if (ptr == NULL || *ptr == NULL) return NULL;
  
  const char* cmd = *ptr;
  
  // 跳过前导空格或分号
  while (*cmd == ' ' || *cmd == ';') cmd++;
  
  // 如果到达字符串末尾，返回 NULL
  if (*cmd == '\0') return NULL;
  
  // 查找命令结束位置（分号或字符串末尾）
  const char * cmdend = cmd;
  while (*cmdend != '\0' && *cmdend != ';') cmdend++;
  
  // 展开 %p 占位符并复制到缓冲区
  Arguments::copy_expand_pid(cmd, cmdend - cmd, buf, buflen);
  
  // 更新指针位置（跳过当前命令和分号）
  *ptr = (*cmdend == '\0' ? cmdend : cmdend + 1);
  return buf;
}

void report_java_out_of_memory(const char* message) {
  static int out_of_memory_reported = 0;
  
  // 使用原子操作确保只执行一次（多个线程可能同时触发）
  if (Atomic::cmpxchg(&out_of_memory_reported, 0, 1) == 0) {
    // 1. 先执行 Java 对象堆转储（如果启用）
    if (HeapDumpOnOutOfMemoryError) {
      tty->print_cr("java.lang.OutOfMemoryError: %s", message);
      HeapDumper::dump_heap_from_oome();
    }
    
    // 2. 执行 OnOutOfMemoryError 命令（如果启用）
    if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
      VMError::report_java_out_of_memory(message);
    }
    
    // 3. 触发崩溃（如果启用）
    if (CrashOnOutOfMemoryError) {
      // ... 省略 ...
    }
    
    // 4. 退出 JVM（如果启用）
    if (ExitOnOutOfMemoryError) {
      // ... 省略 ...
    }
  }
}

class VM_ReportJavaOutOfMemory : public VM_Operation {
 private:
  const char* _message;
 public:
  VM_ReportJavaOutOfMemory(const char* message) { _message = message; }
  VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; }
  void doit();
};

void VM_ReportJavaOutOfMemory::doit() {
  // 不在栈上分配大缓冲区
  static char buffer[O_BUFLEN];
  
  // 打印错误信息和命令信息
  tty->print_cr("#");
  tty->print_cr("# java.lang.OutOfMemoryError: %s", _message);
  tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError);
  
  // 确保 Java 对象堆可解析（不需要 retire TLABs）
  Universe::heap()->ensure_parsability(false);
  
  // 解析并执行每个命令
  char* cmd;
  const char* ptr = OnOutOfMemoryError;
  while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL) {
    tty->print("#   Executing ");
#if defined(LINUX)
    tty->print("/bin/sh -c ");  // Linux 使用 /bin/sh -c 执行
#endif
    tty->print_cr("\"%s\"...", cmd);
    
    // 执行命令（fork 子进程执行，不等待完成）
    if (os::fork_and_exec(cmd, true) < 0) {
      // 执行失败时打印错误信息，但继续执行后续命令
      tty->print_cr("os::fork_and_exec failed: %s (%s=%d)",
                     os::strerror(errno), os::errno_name(errno), errno);
    }
  }
}

void VMError::report_java_out_of_memory(const char* message) {
  if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
    // 获取 Heap_lock 锁，确保线程安全
    MutexLocker ml(Heap_lock);
    // 创建 VM_Operation 并通过 VMThread 在安全点执行
    VM_ReportJavaOutOfMemory op(message);
    VMThread::execute(&op);
  }
}

if (os::fork_and_exec(cmd, true) < 0) {
  // 执行失败时打印错误信息，但继续执行后续命令
  tty->print_cr("os::fork_and_exec failed: %s (%s=%d)",
                 os::strerror(errno), os::errno_name(errno), errno);
}

void report_java_out_of_memory(const char* message) {
  static int out_of_memory_reported = 0;
  
  // 原子操作确保只执行一次
  if (Atomic::cmpxchg(&out_of_memory_reported, 0, 1) == 0) {
    // 1. 最先执行：Java 对象堆转储（如果启用）
    if (HeapDumpOnOutOfMemoryError) {
      tty->print_cr("java.lang.OutOfMemoryError: %s", message);
      HeapDumper::dump_heap_from_oome();
    }
    
    // 2. 然后执行：OnOutOfMemoryError 命令（如果启用）
    if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
      VMError::report_java_out_of_memory(message);
    }
    
    // 3. 接着执行：触发崩溃（如果启用）
    if (CrashOnOutOfMemoryError) {
      tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
      report_fatal(OOM_JAVA_HEAP_FATAL, __FILE__, __LINE__, "OutOfMemory encountered: %s", message);
    }
    
    // 4. 最后执行：退出 JVM（如果启用）
    if (ExitOnOutOfMemoryError) {
      tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
      os::exit(3);  // JDK 17
      // os::_exit(3);  // JDK 21+
    }
  }
}

void report_java_out_of_memory(const char* message) {
  // ... 省略其他代码 ...
  
  if (CrashOnOutOfMemoryError) {
    tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
    fatal("OutOfMemory encountered: %s", message);
  }
}

void report_java_out_of_memory(const char* message) {
  // ... 省略其他代码 ...
  
  if (CrashOnOutOfMemoryError) {
    tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
    // JDK 17+: 使用 report_fatal 替代 fatal，提供更详细的错误信息
    report_fatal(OOM_JAVA_HEAP_FATAL, __FILE__, __LINE__, "OutOfMemory encountered: %s", message);
  }
}

void report_java_out_of_memory(const char* message) {
  // ... 省略其他代码 ...
  
  if (ExitOnOutOfMemoryError) {
    tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
    os::exit(3);  // 调用 os::exit，会执行清理钩子
  }
}

void report_java_out_of_memory(const char* message) {
  // ... 省略其他代码 ...
  
  if (ExitOnOutOfMemoryError) {
    tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
    os::_exit(3);  // JDK 21+: 快速退出，不运行清理钩子
  }
}

public void addShutdownHook(Thread hook) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new RuntimePermission("shutdownHooks"));
    }
    ApplicationShutdownHooks.add(hook);
}

class Shutdown {
    // 系统 shutdown hooks 按预定义槽位注册，执行顺序如下：
    // (0) Console restore hook - 恢复控制台状态
    // (1) ApplicationShutdownHooks - 执行所有应用注册的 shutdown hooks
    // (2) DeleteOnExit hook - 删除标记为退出时删除的文件
    private static final int MAX_SYSTEM_HOOKS = 10;
    private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];
    
    private static void runHooks() {
        // 按顺序执行所有系统 shutdown hooks
        for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
            Runnable hook = hooks[i];
            if (hook != null) hook.run();
        }
        // 设置 shutdown 状态
        VM.shutdown();
    }
    
    static void exit(int status) {
        synchronized (Shutdown.class) {
            beforeHalt();  // 通知 VM 准备退出
            runHooks();    // 执行所有 shutdown hooks
            halt(status);  // 调用 native halt 终止进程
        }
    }
}

class ApplicationShutdownHooks {
    private static IdentityHashMap<Thread, Thread> hooks;
    
    static void runHooks() {
        Collection<Thread> threads;
        synchronized(ApplicationShutdownHooks.class) {
            threads = hooks.keySet();
            hooks = null;  // 清空 hooks，防止重复执行
        }
        
        // 启动所有应用 shutdown hooks（并发执行）
        for (Thread hook : threads) {
            hook.start();
        }
        
        // 等待所有 hooks 完成
        for (Thread hook : threads) {
            while (true) {
                try {
                    hook.join();
                    break;
                } catch (InterruptedException ignored) {
                }
            }
        }
    }
}

void os::exit(int num) {
  ::exit(num);  // 调用标准 C 库的 exit()，会执行 atexit 注册的函数
}

void vm_direct_exit(int code) {
  notify_vm_shutdown();  // 通知 VM 准备关闭
  os::wait_for_keypress_at_exit();
  os::exit(code);  // 调用 os::exit
}

// Runtime.exit() 最终调用
void Java_java_lang_Shutdown_beforeHalt() {
  // 调用 Shutdown.beforeHalt()，触发 shutdown hooks 执行
  Shutdown::exit(status);
}

void os::_exit(int num) {
  ::_exit(num);  // 调用系统调用 _exit()，直接终止进程，不执行任何清理
}

void os::shutdown() {
  // 允许 PerfMemory 尝试清理持久化资源
  perfMemory_exit();
  
  // 移除文件系统中的对象
  AttachListener::abort();
  
  // 刷新缓冲输出，完成日志文件
  ostream_abort();
  
  // 检查是否有 abort hook
  abort_hook_t abort_hook = Arguments::abort_hook();
  if (abort_hook != NULL) {
    abort_hook();
  }
}