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);
  }
}