iOS底层 - 关于死锁，你了解多少？

static inline void
_dispatch_sync_f_inline(dispatch_queue_t dq, void *ctxt,
    dispatch_function_t func, uintptr_t dc_flags)
{
  if (likely(dq->dq_width == 1)) {
    return _dispatch_barrier_sync_f(dq, ctxt, func, dc_flags);
  }

  if (unlikely(dx_metatype(dq) != _DISPATCH_LANE_TYPE)) {
    DISPATCH_CLIENT_CRASH(0, "Queue type doesn't support dispatch_sync");
  }

  dispatch_lane_t dl = upcast(dq)._dl;
  // 全局并发队列和绑定到非分派线程的队列
  // 总是落在慢的情况下 DISPATCH_ROOT_QUEUE_STATE_INIT_VALUE
  if (unlikely(!_dispatch_queue_try_reserve_sync_width(dl))) {
    return _dispatch_sync_f_slow(dl, ctxt, func, 0, dl, dc_flags);
  }

  if (unlikely(dq->do_targetq->do_targetq)) {
    return _dispatch_sync_recurse(dl, ctxt, func, dc_flags);
  }
  _dispatch_introspection_sync_begin(dl);
  _dispatch_sync_invoke_and_complete(dl, ctxt, func DISPATCH_TRACE_ARG(
      _dispatch_trace_item_sync_push_pop(dq, ctxt, func, dc_flags)));
}

static void
_dispatch_barrier_sync_f(dispatch_queue_t dq, void *ctxt,
dispatch_function_t func, uintptr_t dc_flags)
{
_dispatch_barrier_sync_f_inline(dq, ctxt, func, dc_flags);
}

DISPATCH_ALWAYS_INLINE
static inline void
_dispatch_barrier_sync_f_inline(dispatch_queue_t dq, void *ctxt,
    dispatch_function_t func, uintptr_t dc_flags)
{
  dispatch_tid tid = _dispatch_tid_self();

  if (unlikely(dx_metatype(dq) != _DISPATCH_LANE_TYPE)) {
    DISPATCH_CLIENT_CRASH(0, "Queue type doesn't support dispatch_sync");
  }

  dispatch_lane_t dl = upcast(dq)._dl;
  // 更正确的做法是合并线程的qos
  // 刚刚获得了进入队列状态的barrier锁。
  //
  // 然而，这对于快速路径来说太昂贵了，所以跳过它。
  // 选择的权衡是，如果队列在较低优先级的线程上
  // 与此快速路径，此线程可能收到无用的覆盖。
  //
  // 全局并发队列和绑定到非分派线程的队列
  // 总是落在慢的情况下 DISPATCH_ROOT_QUEUE_STATE_INIT_VALUE
  if (unlikely(!_dispatch_queue_try_acquire_barrier_sync(dl, tid))) {
    return _dispatch_sync_f_slow(dl, ctxt, func, DC_FLAG_BARRIER, dl,
        DC_FLAG_BARRIER | dc_flags);
  }

  if (unlikely(dl->do_targetq->do_targetq)) {
    return _dispatch_sync_recurse(dl, ctxt, func,
        DC_FLAG_BARRIER | dc_flags);
  }
  _dispatch_introspection_sync_begin(dl);
  _dispatch_lane_barrier_sync_invoke_and_complete(dl, ctxt, func
      DISPATCH_TRACE_ARG(_dispatch_trace_item_sync_push_pop(
          dq, ctxt, func, dc_flags | DC_FLAG_BARRIER)));
}

DISPATCH_NOINLINE
static void
_dispatch_sync_f_slow(dispatch_queue_class_t top_dqu, void *ctxt,
    dispatch_function_t func, uintptr_t top_dc_flags,
    dispatch_queue_class_t dqu, uintptr_t dc_flags)
{
  dispatch_queue_t top_dq = top_dqu._dq;
  dispatch_queue_t dq = dqu._dq;
  if (unlikely(!dq->do_targetq)) {
    return _dispatch_sync_function_invoke(dq, ctxt, func);
  }

  pthread_priority_t pp = _dispatch_get_priority();
  struct dispatch_sync_context_s dsc = {
    .dc_flags    = DC_FLAG_SYNC_WAITER | dc_flags,
    .dc_func     = _dispatch_async_and_wait_invoke,
    .dc_ctxt     = &dsc,
    .dc_other    = top_dq,
    .dc_priority = pp | _PTHREAD_PRIORITY_ENFORCE_FLAG,
    .dc_voucher  = _voucher_get(),
    .dsc_func    = func,
    .dsc_ctxt    = ctxt,
    .dsc_waiter  = _dispatch_tid_self(),
  };

  _dispatch_trace_item_push(top_dq, &dsc);
  __DISPATCH_WAIT_FOR_QUEUE__(&dsc, dq);

  if (dsc.dsc_func == NULL) {
    // dsc_func being cleared means that the block ran on another thread ie.
    // case (2) as listed in _dispatch_async_and_wait_f_slow.
    dispatch_queue_t stop_dq = dsc.dc_other;
    return _dispatch_sync_complete_recurse(top_dq, stop_dq, top_dc_flags);
  }

  _dispatch_introspection_sync_begin(top_dq);
  _dispatch_trace_item_pop(top_dq, &dsc);
  _dispatch_sync_invoke_and_complete_recurse(top_dq, ctxt, func,top_dc_flags
      DISPATCH_TRACE_ARG(&dsc));
}

DISPATCH_NOINLINE
static void
__DISPATCH_WAIT_FOR_QUEUE__(dispatch_sync_context_t dsc, dispatch_queue_t dq)
{
    uint64_t dq_state = _dispatch_wait_prepare(dq);
    if (unlikely(_dq_state_drain_locked_by(dq_state, dsc->dsc_waiter))) {
            DISPATCH_CLIENT_CRASH((uintptr_t)dq_state,
                            "dispatch_sync called on queue "
                            "already owned by current thread");
    }

    ...

}

// 1、当前的队列线程的线程ID
#define _dispatch_tid_self() ((dispatch_tid)_dispatch_thread_port())

#define _dispatch_thread_port() pthread_mach_thread_np(_dispatch_thread_self())

#define _dispatch_thread_self() ((uintptr_t)pthread_self())

// 2、队列的状态
 _dispatch_wait_prepare(dq);

ISPATCH_ALWAYS_INLINE
static inline bool
_dq_state_drain_locked_by(uint64_t dq_state, dispatch_tid tid)
{
  return _dispatch_lock_is_locked_by((dispatch_lock)dq_state, tid);
}

#define DLOCK_OWNER_MASK ((dispatch_lock)0xfffffffc)

DISPATCH_ALWAYS_INLINE
static inline bool
_dispatch_lock_is_locked_by(dispatch_lock lock_value, dispatch_tid tid)
{
  // equivalent to _dispatch_lock_owner(lock_value) == tid
        // DLOCK_OWNER_MASK 是一个很大的数 ((dispatch_lock)0xfffffffc)
        // 前面的结果只要不为0 与上 DLOCK_OWNER_MASK 也不为0
        // 如果前面的结果与上DLOCK_OWNER_MASK结果为0 那前面的结果 必然为0
        // 最终， lock_value 和 tid 相同 才会 为 0
  return ((lock_value ^ tid) & DLOCK_OWNER_MASK) == 0;
}