void AdvancedThresholdPolicy::initialize() {
  // CICompilerCountPerCPU默認值為false，表示是否每個CPU對應1個後台編譯執行緒，
  // CICompilerCount表示後台編譯執行緒的數量，默認值3
  // 當這兩個選項配置都是默認值時，將CICompilerCountPerCPU設置為true
  if (FLAG_IS_DEFAULT(CICompilerCountPerCPU) && FLAG_IS_DEFAULT(CICompilerCount)) {
    FLAG_SET_DEFAULT(CICompilerCountPerCPU, true);
  }

  int count = CICompilerCount;
  if (CICompilerCountPerCPU) { 
    //考慮機器的CPU數量，計算總的後台編譯執行緒數
    int log_cpu = log2_int(os::active_processor_count());
    int loglog_cpu = log2_int(MAX2(log_cpu, 1));
    count = MAX2(log_cpu * loglog_cpu, 1) * 3 / 2;
  }
 
  // 計算C1,C2編譯執行緒的數量，按照1:2的比例進行分配
  set_c1_count(MAX2(count / 3, 1));
  set_c2_count(MAX2(count - c1_count(), 1));

  // 重置CICompilerCount
  FLAG_SET_ERGO(intx, CICompilerCount, c1_count() + c2_count());
 

  // InlineSmallCode表示只有當方法程式碼的大小小於該值時才會使用內聯編譯的方式，x86下默認是1000
  // 這裡是將其調整為2000
  if (FLAG_IS_DEFAULT(InlineSmallCode)) {
    FLAG_SET_DEFAULT(InlineSmallCode, 2000);
  }
 
  // 當CodeCache已使用了指定比例時提升C1編譯的閾值
  set_increase_threshold_at_ratio();  
}
 
// IncreaseFirstTierCompileThresholdAt默認是50%，當CodeCache的
// 已使用量大於50%時就會開始提高觸發C1編譯的閾值
void set_increase_threshold_at_ratio() { 
   _increase_threshold_at_ratio = 100 / (100 - (double)IncreaseFirstTierCompileThresholdAt); 
}

Threads::create_vm()  thread.cpp    
CompileBroker::compilation_init()  compileBroker.cpp  

void CompileBroker::compilation_init() {
  if (!UseCompiler) { // 不使用編譯器就不需要初始化
    return;
  }

    // 返回前面計算出的編譯器執行緒數量
    int c1_count = CompilationPolicy::policy()->compiler_count(CompLevel_simple);
    int c2_count = CompilationPolicy::policy()->compiler_count(CompLevel_full_optimization);
    if (c1_count > 0) {
	_compilers[0] = new Compiler(); // C1編譯器為Compiler
    }

    if (c2_count > 0) {
	_compilers[1] = new C2Compiler(); // C2編譯器為C2Compiler
    }

    // 啟動編譯執行緒
    init_compiler_threads(c1_count, c2_count);
  
    // ...
}

void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) {

  // 初始化編譯執行緒任務隊列
  if (c2_compiler_count > 0) {
    _c2_method_queue  = new CompileQueue("C2MethodQueue",  MethodCompileQueue_lock);
    _compilers[1]->set_num_compiler_threads(c2_compiler_count);
  }
  if (c1_compiler_count > 0) {
    _c1_method_queue  = new CompileQueue("C1MethodQueue",  MethodCompileQueue_lock);
    _compilers[0]->set_num_compiler_threads(c1_compiler_count);
  }

  int compiler_count = c1_compiler_count + c2_compiler_count;

  _compiler_threads = new (ResourceObj::C_HEAP, mtCompiler) GrowableArray<CompilerThread*>(compiler_count, true);

  char name_buffer[256];
  // 創建C2編譯器執行緒
  for (int i = 0; i < c2_compiler_count; i++) {
    CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, _compilers[1], CHECK);
    _compiler_threads->append(new_thread);
  }

  // 創建C1編譯器執行緒
  for (int i = c2_compiler_count; i < compiler_count; i++) {
    CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, _compilers[0], CHECK);
    _compiler_threads->append(new_thread);
  }
}