alarm_t* alarm_new(const char* name)；

alarm_t* alarm_new_periodic(const char* name) ；

static alarm_t* alarm_new_internal(const char* name, bool is_periodic) ；

void alarm_free(alarm_t* alarm)；

void alarm_set(alarm_t* alarm, period_ms_t interval_ms, alarm_callback_t cb,

               void* data) ；

void alarm_cancel(alarm_t* alarm)；

void alarm_cleanup(void)；

static bool lazy_initialize(void) ；

 startup_timer = alarm_new("hci.startup_timer");

...

 alarm_set(startup_timer, startup_timeout_ms, startup_timer_expired, NULL); 

alarm_t* alarm_new(const char* name) { return alarm_new_internal(name, false); }

static alarm_t* alarm_new_internal(const char* name, bool is_periodic) {

  // Make sure we have a list we can insert alarms into.

  if (!alarms && !lazy_initialize()) { //最初alarm 还没有初始化，需要执行初始化流程

    CHECK(false);  // if initialization failed, we should not continue

    return NULL;

  }

  alarm_t* ret = static_cast<alarm_t*>(osi_calloc(sizeof(alarm_t)));

  ret->callback_mutex = new std::recursive_mutex;

  ret->is_periodic = is_periodic;

  ret->stats.name = osi_strdup(name);

  // NOTE: The stats were reset by osi_calloc() above

  return ret;

}

static bool lazy_initialize(void) {

  bool timer_initialized = false;

  bool wakeup_timer_initialized = false;

  std::lock_guard<std::mutex> lock(alarms_mutex);

  alarms = list_new(NULL);

  if (!timer_create_internal(CLOCK_ID, &timer)) goto error;//timer_create

  timer_initialized = true;

  if (!timer_create_internal(CLOCK_ID_ALARM, &wakeup_timer)) goto error;

  wakeup_timer_initialized = true;

  alarm_expired = semaphore_new();//新建信号量

  default_callback_thread =

      thread_new_sized("alarm_default_callbacks", SIZE_MAX);//新建线程

  thread_set_rt_priority(default_callback_thread, THREAD_RT_PRIORITY);//提高线程优先级

  default_callback_queue = fixed_queue_new(SIZE_MAX);//新建队列

  alarm_register_processing_queue(default_callback_queue,

                                  default_callback_thread);//将线程和队列绑定

  dispatcher_thread_active = true;

  dispatcher_thread = thread_new("alarm_dispatcher");//新建定时器分发线程,该线程不停运行while(true)

  thread_set_rt_priority(dispatcher_thread, THREAD_RT_PRIORITY);

  thread_post(dispatcher_thread, callback_dispatch, NULL);//运行callback_dispatch

  return true;

error:

  ...

  return false;

}

static bool timer_create_internal(const clockid_t clock_id, timer_t* timer) {

  CHECK(timer != NULL);

  struct sigevent sigevent;

  // create timer with RT priority thread

  pthread_attr_t thread_attr;

  pthread_attr_init(&thread_attr);

  pthread_attr_setschedpolicy(&thread_attr, SCHED_FIFO);

  struct sched_param param;

  param.sched_priority = THREAD_RT_PRIORITY;

  pthread_attr_setschedparam(&thread_attr, &param);

  memset(&sigevent, , sizeof(sigevent));

  sigevent.sigev_notify = SIGEV_THREAD;

  sigevent.sigev_notify_function = (void (*)(union sigval))timer_callback;//发送信号量

  sigevent.sigev_notify_attributes = &thread_attr;

  if (timer_create(clock_id, &sigevent, timer) == -) {  //创建定时器

    /*错误处理*/

    }

    return false;

  }

  return true;

}

static void timer_callback(UNUSED_ATTR void* ptr) {

  semaphore_post(alarm_expired);

}

static void callback_dispatch(UNUSED_ATTR void* context) {

  while (true) {

    semaphore_wait(alarm_expired);//一直循环等待信号量

...

    }

}

void alarm_set(alarm_t* alarm, period_ms_t interval_ms, alarm_callback_t cb,

               void* data) {

  alarm_set_on_queue(alarm, interval_ms, cb, data, default_callback_queue);

}

void alarm_set_on_queue(alarm_t* alarm, period_ms_t interval_ms,

                        alarm_callback_t cb, void* data, fixed_queue_t* queue) {

  CHECK(queue != NULL);

  alarm_set_internal(alarm, interval_ms, cb, data, queue);

}

// Runs in exclusion with alarm_cancel and timer_callback.

static void alarm_set_internal(alarm_t* alarm, period_ms_t period,

                               alarm_callback_t cb, void* data,

                               fixed_queue_t* queue) {

  std::lock_guard<std::mutex> lock(alarms_mutex);

  alarm->creation_time = now();

  alarm->period = period;

  alarm->queue = queue;

  alarm->callback = cb;

  alarm->data = data;

  schedule_next_instance(alarm);

  alarm->stats.scheduled_count++;

}

// Must be called with |alarms_mutex| held

static void schedule_next_instance(alarm_t* alarm) {

  // If the alarm is currently set and it's at the start of the list,

  // we'll need to re-schedule since we've adjusted the earliest deadline.

  bool needs_reschedule =

      (!list_is_empty(alarms) && list_front(alarms) == alarm);//如果alarms 队列第一个元素就是这个定时器,那么需要重启schedule

  if (alarm->callback) remove_pending_alarm(alarm);//取出所有的pending,重复的alarm

  // Calculate the next deadline for this alarm

  period_ms_t just_now = now();

  period_ms_t ms_into_period = ;

  if ((alarm->is_periodic) && (alarm->period != ))

    ms_into_period = ((just_now - alarm->creation_time) % alarm->period);

  alarm->deadline = just_now + (alarm->period - ms_into_period);

  // Add it into the timer list sorted by deadline (earliest deadline first).//以下是给alarm排序,插入到某个合适的问题,最近的alarm 排在第一个

  if (list_is_empty(alarms) ||

      ((alarm_t*)list_front(alarms))->deadline > alarm->deadline) {

    list_prepend(alarms, alarm);

  } else {

    for (list_node_t* node = list_begin(alarms); node != list_end(alarms);

         node = list_next(node)) {

      list_node_t* next = list_next(node);

      if (next == list_end(alarms) ||

          ((alarm_t*)list_node(next))->deadline > alarm->deadline) {

        list_insert_after(alarms, node, alarm);

        break;

      }

    }

  }

  // If the new alarm has the earliest deadline, we need to re-evaluate our

  // schedule.

  if (needs_reschedule ||

      (!list_is_empty(alarms) && list_front(alarms) == alarm)) {

    reschedule_root_alarm();

  }

}

// NOTE: must be called with |alarms_mutex| held

static void reschedule_root_alarm(void) {

  CHECK(alarms != NULL);

  const bool timer_was_set = timer_set;

  alarm_t* next;

  int64_t next_expiration;

  // If used in a zeroed state, disarms the timer.

  struct itimerspec timer_time;

  memset(&timer_time, , sizeof(timer_time));

  if (list_is_empty(alarms)) goto done;

  next = static_cast<alarm_t*>(list_front(alarms));

  next_expiration = next->deadline - now();

  if (next_expiration < TIMER_INTERVAL_FOR_WAKELOCK_IN_MS) {//如果deadline<3s>

    timer_time.it_value.tv_sec = (next->deadline / );

    timer_time.it_value.tv_nsec = (next->deadline % ) * 1000000LL;

/*下面设置最长的wake_up 是为了减少删除该timer的开销,可以略过*/

    struct itimerspec end_of_time;

    memset(&end_of_time, , sizeof(end_of_time));

    end_of_time.it_value.tv_sec = (time_t)(1LL << (sizeof(time_t) *  - ));

    timer_settime(wakeup_timer, TIMER_ABSTIME, &end_of_time, NULL);

  } else {

    // WARNING: do not attempt to use relative timers with *_ALARM clock IDs

    // in kernels before 3.17 unless you have the following patch:

    // https://lkml.org/lkml/2014/7/7/576

    struct itimerspec wakeup_time;

    memset(&wakeup_time, , sizeof(wakeup_time));

    wakeup_time.it_value.tv_sec = (next->deadline / );

    wakeup_time.it_value.tv_nsec = (next->deadline % ) * 1000000LL;

    if (timer_settime(wakeup_timer, TIMER_ABSTIME, &wakeup_time, NULL) == -)

      LOG_ERROR(LOG_TAG, "%s unable to set wakeup timer: %s", __func__,

                strerror(errno));

  }

done:

  timer_set =

      timer_time.it_value.tv_sec !=  || timer_time.it_value.tv_nsec != ;

  if (timer_was_set && !timer_set) {

    wakelock_release();

  }

  if (timer_settime(timer, TIMER_ABSTIME, &timer_time, NULL) == -)

    LOG_ERROR(LOG_TAG, "%s unable to set timer: %s", __func__, strerror(errno));//设置定时器

  // If next expiration was in the past (e.g. short timer that got context

  // switched) then the timer might have diarmed itself. Detect this case and

  // work around it by manually signalling the |alarm_expired| semaphore.

  //

  // It is possible that the timer was actually super short (a few

  // milliseconds) and the timer expired normally before we called

  // |timer_gettime|. Worst case, |alarm_expired| is signaled twice for that

  // alarm. Nothing bad should happen in that case though since the callback

  // dispatch function checks to make sure the timer at the head of the list

  // actually expired.

  if (timer_set) {

    struct itimerspec time_to_expire;

    timer_gettime(timer, &time_to_expire);

    if (time_to_expire.it_value.tv_sec ==  &&

        time_to_expire.it_value.tv_nsec == ) {

      semaphore_post(alarm_expired);//如果定时器的时机已经到了,那么直接发送信号量

    }

  }

}

// Function running on |dispatcher_thread| that performs the following:

//   (1) Receives a signal using |alarm_exired| that the alarm has expired

//   (2) Dispatches the alarm callback for processing by the corresponding

// thread for that alarm.

static void callback_dispatch(UNUSED_ATTR void* context) {

  while (true) {

    semaphore_wait(alarm_expired);//等待expire的信号量

    if (!dispatcher_thread_active) break;

    std::lock_guard<std::mutex> lock(alarms_mutex);

    alarm_t* alarm;

    // Take into account that the alarm may get cancelled before we get to it.

    // We're done here if there are no alarms or the alarm at the front is in

    // the future. Exit right away since there's nothing left to do.

    if (list_is_empty(alarms) ||

        (alarm = static_cast<alarm_t*>(list_front(alarms)))->deadline > now()) {

      reschedule_root_alarm();

      continue;

    }

    list_remove(alarms, alarm);//remove 该alarm 从队列中

    if (alarm->is_periodic) {

      alarm->prev_deadline = alarm->deadline;

      schedule_next_instance(alarm);

      alarm->stats.rescheduled_count++;

    }

    reschedule_root_alarm();//去启动下一个定时器

    // Enqueue the alarm for processing

    fixed_queue_enqueue(alarm->queue, alarm);//将该expire的定时器放到相应队列等待处理

  }

  LOG_DEBUG(LOG_TAG, "%s Callback thread exited", __func__);

}

void alarm_register_processing_queue(fixed_queue_t* queue, thread_t* thread) {

  CHECK(queue != NULL);

  CHECK(thread != NULL);

  fixed_queue_register_dequeue(queue, thread_get_reactor(thread),

                               alarm_queue_ready, NULL);

}

static void alarm_queue_ready(fixed_queue_t* queue, UNUSED_ATTR void* context) {

  CHECK(queue != NULL);

  std::unique_lock<std::mutex> lock(alarms_mutex);

  alarm_t* alarm = (alarm_t*)fixed_queue_try_dequeue(queue);

  if (alarm == NULL) {

    return;  // The alarm was probably canceled

  }

  //

  // If the alarm is not periodic, we've fully serviced it now, and can reset

  // some of its internal state. This is useful to distinguish between expired

  // alarms and active ones.

  //

  alarm_callback_t callback = alarm->callback;

  void* data = alarm->data;

  period_ms_t deadline = alarm->deadline;

  if (alarm->is_periodic) {

    // The periodic alarm has been rescheduled and alarm->deadline has been

    // updated, hence we need to use the previous deadline.

    deadline = alarm->prev_deadline;

  } else {

    alarm->deadline = ;

    alarm->callback = NULL;

    alarm->data = NULL;

    alarm->queue = NULL;

  }

  std::lock_guard<std::recursive_mutex> cb_lock(*alarm->callback_mutex);

  lock.unlock();

  period_ms_t t0 = now();

  callback(data);//执行callback 函数,并reset alarm

  period_ms_t t1 = now();

  // Update the statistics

  CHECK(t1 >= t0);

  period_ms_t delta = t1 - t0;

  update_scheduling_stats(&alarm->stats, t0, deadline, delta);

}