java中的safepoint详解

public class TestNull {

 public static void main(String[] args) throws InterruptedException {
  List<String> list= new ArrayList();
 list.add("www.flydean.com");
  for (int i = 0; i < 10000; i++)
  {
   testMethod(list);
  }
  Thread.sleep(1000);
 }

 private static void testMethod(List<String> list)
 {
  list.get(0);
 }
}

// Roll all threads forward to a safepoint and suspend them all
void SafepointSynchronize::begin() {
 Thread* myThread = Thread::current();
 assert(myThread->is_VM_thread(), "Only VM thread may execute a safepoint");
 
 if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {
  _safepoint_begin_time = os::javaTimeNanos();
  _ts_of_current_safepoint = tty->time_stamp().seconds();
 }

void TemplateInterpreter::notice_safepoints() {
 if (!_notice_safepoints) {
  // switch to safepoint dispatch table
  _notice_safepoints = true;
  copy_table((address*)&_safept_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address));
 }
}

// Serialize all thread state variables
void os::serialize_thread_states() {
 // On some platforms such as Solaris & Linux, the time duration of the page
 // permission restoration is observed to be much longer than expected due to
 // scheduler starvation problem etc. To avoid the long synchronization
 // time and expensive page trap spinning, 'SerializePageLock' is used to block
 // the mutator thread if such case is encountered. See bug 6546278 for details.
 Thread::muxAcquire(&SerializePageLock, "serialize_thread_states");
 os::protect_memory((char *)os::get_memory_serialize_page(),
           os::vm_page_size(), MEM_PROT_READ);
 os::protect_memory((char *)os::get_memory_serialize_page(),
           os::vm_page_size(), MEM_PROT_RW);
 Thread::muxRelease(&SerializePageLock);
}

if (UseCompilerSafepoints && DeferPollingPageLoopCount < 0) {
  // Make polling safepoint aware
  guarantee (PageArmed == 0, "invariant") ;
  PageArmed = 1 ;
  os::make_polling_page_unreadable();
}

// Mark the polling page as unreadable
void os::make_polling_page_unreadable(void) {
 if( !guard_memory((char*)_polling_page, Linux::page_size()) )
  fatal("Could not disable polling page");
};

// Mark the polling page as unreadable
void os::make_polling_page_unreadable(void) {
 if( mprotect((char *)_polling_page, page_size, PROT_NONE) != 0 )
  fatal("Could not disable polling page");
};

hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
// Check to see if we caught the safepoint code in the
// process of write protecting the memory serialization page.
// It write enables the page immediately after protecting it
// so we can just return to retry the write.
if ((sig == SIGSEGV) &&
  os::is_memory_serialize_page(thread, (address) info->si_addr)) {
 // Block current thread until the memory serialize page permission restored.
 os::block_on_serialize_page_trap();
 return true;
}

if (PageArmed) {
  // Make polling safepoint aware
  os::make_polling_page_readable();
  PageArmed = 0 ;
 }

// switch from the dispatch table which notices safepoints back to the
// normal dispatch table. So that we can notice single stepping points,
// keep the safepoint dispatch table if we are single stepping in JVMTI.
// Note that the should_post_single_step test is exactly as fast as the
// JvmtiExport::_enabled test and covers both cases.
void TemplateInterpreter::ignore_safepoints() {
 if (_notice_safepoints) {
  if (!JvmtiExport::should_post_single_step()) {
   // switch to normal dispatch table
   _notice_safepoints = false;
   copy_table((address*)&_normal_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address));
  }
 }
}

// Start suspended threads
  for(JavaThread *current = Threads::first(); current; current = current->next()) {
   // A problem occurring on Solaris is when attempting to restart threads
   // the first #cpus - 1 go well, but then the VMThread is preempted when we get
   // to the next one (since it has been running the longest). We then have
   // to wait for a cpu to become available before we can continue restarting
   // threads.
   // FIXME: This causes the performance of the VM to degrade when active and with
   // large numbers of threads. Apparently this is due to the synchronous nature
   // of suspending threads.
   //
   // TODO-FIXME: the comments above are vestigial and no longer apply.
   // Furthermore, using solaris' schedctl in this particular context confers no benefit
   if (VMThreadHintNoPreempt) {
    os::hint_no_preempt();
   }
   ThreadSafepointState* cur_state = current->safepoint_state();
   assert(cur_state->type() != ThreadSafepointState::_running, "Thread not suspended at safepoint");
   cur_state->restart();
   assert(cur_state->is_running(), "safepoint state has not been reset");
  }

Total time for which application threads were stopped: 0.0051000 seconds 
Total time for which application threads were stopped: 0.0041930 seconds 
Total time for which application threads were stopped: 0.0051210 seconds 
Total time for which application threads were stopped: 0.0050940 seconds 
Total time for which application threads were stopped: 0.0058720 seconds 
Total time for which application threads were stopped: 5.1298200 seconds
Total time for which application threads were stopped: 0.0197290 seconds 
Total time for which application threads were stopped: 0.0087590 seconds