@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
  if (event.getApplicationContext() == this.applicationContext) {
    // Running in an ApplicationContext -> register tasks this late...
    // giving other ContextRefreshedEvent listeners a chance to perform
    // their work at the same time (e.g. Spring Batch's job registration).
    finishRegistration();
  }
}

private void finishRegistration() {
  if (this.scheduler != null) {
    this.registrar.setScheduler(this.scheduler);
  }

  if (this.beanFactory instanceof ListableBeanFactory) {
    Map<String, SchedulingConfigurer> beans =
        ((ListableBeanFactory) this.beanFactory).getBeansOfType(SchedulingConfigurer.class);
    List<SchedulingConfigurer> configurers = new ArrayList<SchedulingConfigurer>(beans.values());
    AnnotationAwareOrderComparator.sort(configurers);
    for (SchedulingConfigurer configurer : configurers) {
      configurer.configureTasks(this.registrar);
    }
  }

  if (this.registrar.hasTasks() && this.registrar.getScheduler() == null) {
    Assert.state(this.beanFactory != null, "BeanFactory must be set to find scheduler by type");
    try {
      // Search for TaskScheduler bean...
      this.registrar.setTaskScheduler(resolveSchedulerBean(TaskScheduler.class, false));
    }
    catch (NoUniqueBeanDefinitionException ex) {
      logger.debug("Could not find unique TaskScheduler bean", ex);
      try {
        this.registrar.setTaskScheduler(resolveSchedulerBean(TaskScheduler.class, true));
      }
      catch (NoSuchBeanDefinitionException ex2) {
        if (logger.isInfoEnabled()) {
          logger.info("More than one TaskScheduler bean exists within the context, and " +
              "none is named 'taskScheduler'. Mark one of them as primary or name it 'taskScheduler' " +
              "(possibly as an alias); or implement the SchedulingConfigurer interface and call " +
              "ScheduledTaskRegistrar#setScheduler explicitly within the configureTasks() callback: " +
              ex.getBeanNamesFound());
        }
      }
    }
    catch (NoSuchBeanDefinitionException ex) {
      logger.debug("Could not find default TaskScheduler bean", ex);
      // Search for ScheduledExecutorService bean next...
      try {
        this.registrar.setScheduler(resolveSchedulerBean(ScheduledExecutorService.class, false));
      }
      catch (NoUniqueBeanDefinitionException ex2) {
        logger.debug("Could not find unique ScheduledExecutorService bean", ex2);
        try {
          this.registrar.setScheduler(resolveSchedulerBean(ScheduledExecutorService.class, true));
        }
        catch (NoSuchBeanDefinitionException ex3) {
          if (logger.isInfoEnabled()) {
            logger.info("More than one ScheduledExecutorService bean exists within the context, and " +
                "none is named 'taskScheduler'. Mark one of them as primary or name it 'taskScheduler' " +
                "(possibly as an alias); or implement the SchedulingConfigurer interface and call " +
                "ScheduledTaskRegistrar#setScheduler explicitly within the configureTasks() callback: " +
                ex2.getBeanNamesFound());
          }
        }
      }
      catch (NoSuchBeanDefinitionException ex2) {
        logger.debug("Could not find default ScheduledExecutorService bean", ex2);
        // Giving up -> falling back to default scheduler within the registrar...
        logger.info("No TaskScheduler/ScheduledExecutorService bean found for scheduled processing");
      }
    }
  }

  this.registrar.afterPropertiesSet();
}

static {
    long a = unsafe.allocateMemory(8);
    try {
        unsafe.putLong(a, 0x0102030405060708L);
        byte b = unsafe.getByte(a);
        switch (b) {
        case 0x01: byteOrder = ByteOrder.BIG_ENDIAN;     break;
        case 0x08: byteOrder = ByteOrder.LITTLE_ENDIAN;  break;
        default:
            assert false;
            byteOrder = null;
        }
    } finally {
        unsafe.freeMemory(a);
    }
}

try {
    // If no exception was thrown from map0, the address is valid
    addr = map0(imode, mapPosition, mapSize);
} catch (OutOfMemoryError x) {
    // An OutOfMemoryError may indicate that we've exhausted memory
    // so force gc and re-attempt map
    System.gc();
    try {
        Thread.sleep(100);
    } catch (InterruptedException y) {
        Thread.currentThread().interrupt();
    }
    try {
        addr = map0(imode, mapPosition, mapSize);
    } catch (OutOfMemoryError y) {
        // After a second OOME, fail
        throw new IOException("Map failed", y);
    }
}