从手指从屏幕按下的瞬间，触摸事件经过一系列处理会来到Activity的dispatchTouchEvent中。

Activity.java

public boolean dispatchTouchEvent(MotionEvent ev) {

    if (ev.getAction() == MotionEvent.ACTION_DOWN) {

        onUserInteraction();

    }

    //getWindow().superDispatchTouchEvent(ev) 返回true代表消费了事件

    if (getWindow().superDispatchTouchEvent(ev)) {

        return true;

    }

    //否则调用Activity的onTouchEvent

    return onTouchEvent(ev);

}

 

getWindow()实际返回的是PhoneWindow

PhoneWindow.java

@Override

public boolean superDispatchTouchEvent(MotionEvent event) {

    return mDecor.superDispatchTouchEvent(event);

}

 

getWindow().superDispatchTouchEvent(ev)实际会调用到mDecor.superDispatchTouchEvent(event)

DecorView.java

public class DecorView extends FrameLayout 

    public boolean superDispatchTouchEvent(MotionEvent event) {

        return super.dispatchTouchEvent(event);

    }

}

 

跟踪DecorView会发现DecorView继承自FrameLayout，因为FrameLayout没有重写dispatchTouchEvent方法，所以事件从Activity一路下来，最终事件的入口是ViewGroup的dispatchTouchEvent。

开发中，事件一般通过层层ViewGroup传递到View中，进行消费。一般View做真正的事件消费。

View的事件分发

View.java--伪代码

/**

 * view接收事件的入口，事件由ViewGroup分发过来

 */

public boolean dispatchTouchEvent(MotionEvent event) {

    boolean result = false;



    //如果设置了OnTouchListener，并且mOnTouchListener.onTouch返回了True，

    //设置Result为True,那么代表事件到这已经消费完成了。

    if (mOnTouchListener != null && mOnTouchListener.onTouch(this, event)) {

        result = true;

    }



    //没有设置OnTouchListener，或者mOnTouchListener.onTouch返回了false时，result为false

    //此时会回调View.onTouchEvent方法

    if(!result&& onTouchEvent(event)){

        result = true;

    }

    return result;

}



public boolean onTouchEvent(MotionEvent event) {

    //如果设置了onClickListener，那么返回True代表事件到这已经消费完成了。

    if (onClickListener != null) {

        onClickListener.onClick(this);

        return true;

    }

    return false;

}

 

dispatchTouchEvent是传入事件的入口，如果设置了mOnTouchListener,并且返回了true，那么dispatchTouchEvent就会返回true，代表事件被当前View消费了。如果没有设置，那么就会回调onTouchEvent方法，如果设置了onClickListener，那么onTouchEvent返回true，同理dispatchTouchEvent就会返回true，代表事件被当前View消费了.

从上面可以看出OnTouchListener先于onTouchEvent执行，onTouchEvent先于onClickListener执行。

ViewGroup的事件分发

ViewGroup.java--伪代码

    /**

     * onInterceptTouchEvent 拦截事件

     * @return  true 代表拦截当前事件，那么事件就不会分发给ViewGroup的child View ，会调用自身的 super.dispatchTouchEvent(event)

     *          false 代表不拦截当前事件，不拦截事件，那么在dispatchTouchEvent会遍历child View，寻找能消费事件的child View

     */

    public boolean onInterceptTouchEvent(MotionEvent ev) {

        return false;

    }



    /**

     * @param event 事件

     * @param child 如果child 不为null，那么事件分发给它，否则，调用调用自身的 super.dispatchTouchEvent(event)

     * @return 是否消费了该事件

     */

    private boolean dispatchTransformedTouchEvent(MotionEvent event, View child) {

        boolean handled = false;

        if (child != null) {

            handled = child.dispatchTouchEvent(event);

        } else {

            handled = super.dispatchTouchEvent(event);

        }



        return handled;

    }





    public boolean dispatchTouchEvent(MotionEvent event) {

        boolean handled = false;

        //是否拦截当前事件

        boolean intercepted = onInterceptTouchEvent(event);

        //触碰的对象

        TouchTarget newTouchTarget = null;

        int actionMasked = event.getActionMasked();



        if (actionMasked != MotionEvent.ACTION_CANCEL && !intercepted) {

            if (actionMasked == MotionEvent.ACTION_DOWN) {

                //ViewGroup child View 数组

                final View[] children = mChildren;

                //倒序遍历，最后的通常是需要处理事件的

                for (int i = children.length - 1; i >= 0; i--) {

                    View child = mChildren[i];

                    //isContainer 方法判断事件是否落在View中

                    if (!child.isContainer(event.getX(), event.getY())) {

                        continue;

                    }

                    //找到可以接收事件的View,把事件分发给他，

                    //如果dispatchTransformedTouchEvent返回了True代表消费了事件

                    if (dispatchTransformedTouchEvent(event, child)) {

                        handled = true;

                        //通过child包装成TouchTarget对象

                        newTouchTarget = addTouchTarget(child);

                        break;

                    }



                }

            }

        }

        //如果TouchTarget为null，那么事件就发就自己处理

        //mFirstTouchTarget == null 在onInterceptTouchEvent返回true时，或没有找到可以消费的child View时成立

        if (mFirstTouchTarget == null) {

            handled = dispatchTransformedTouchEvent(event, null);

        }

        return handled;

    }

 

dispatchTouchEvent是事件接收的入口，如果拦截事件，那么就调用super.dispatchTouchEvent(event)，我们知道ViewGroup是继承View的，那么调用super.dispatchTouchEvent(event)等于调用View的dispatchTouchEvent。

View.java

/**

 * view接收事件的入口，事件由ViewGroup分发过来

 */

public boolean dispatchTouchEvent(MotionEvent event) {

    boolean result = false;



    //如果设置了OnTouchListener，并且mOnTouchListener.onTouch返回了True，

    //设置Result为True,那么代表事件到这已经消费完成了。

    if (mOnTouchListener != null && mOnTouchListener.onTouch(this, event)) {

        result = true;

    }



    //没有设置OnTouchListener，或者mOnTouchListener.onTouch返回了false时，result为false

    //此时会回调View.onTouchEvent方法

    if(!result&& onTouchEvent(event)){

        result = true;

    }

    return result;

}

 

如果不拦截，那么就会遍历当前ViewGroup的child view，找能消费事件的View，如果找到，调用dispatchTransformedTouchEvent(event, child)，这里的child可以是ViewGroup或者是View，最后根据dispatchTransformedTouchEvent返回值判断是否消费了事件，如果返回false后，那么调用ViewGroup的super.dispatchTouchEvent(event)

一、概述

Reveal是一款UI调试神器，对iOS开发非常有帮助。这里以版本Version 4 (8796)演示

二、安装

2.1 Mac端安装

Reveal官网直接下载安装，可以用试用版。

2.2 手机端安装

1.cydia直接安装Reveal Loader插件

zaizai:/Library root# mkdir RHRevealLoader

zaizai:/Library root# cd RHRevealLoader/

zaizai:/Library/RHRevealLoader root# pwd

/Library/RHRevealLoader

scp -P 12345 RevealServer root@localhost://Library/RHRevealLoader/libReveal.dylib

zaizai:/Library/RHRevealLoader root# ls

libReveal.dylib*

zaizai:~ root# ps -A | grep SpringBoard

20973 ??         4:01.57 /System/Library/CoreServices/SpringBoard.app/SpringBoard

23213 ttys000    0:00.01 grep SpringBoard

zaizai:~ root# kill 20973

zaizai:~ root#

核心逻辑：

• 根据不同架构找到buckets中sel对应的index，p10 = buckets，p11 = mask / _bucketsAndMaybeMask（arm64_64 是 _bucketsAndMaybeMask），p12 = index。
  • arm64_64的情况下如果_bucketsAndMaybeMask第0位为1则执行LLookupPreopt\Function。
• p13 = buckets + index << 4找到cls对应的buckets地址，地址平移找到对应bucket_t
• do-while循环扫描buckets[index]的前半部分（后半部分逻辑不在这里）。
  • 如果存在sel为空，则说明是没有缓存的，就直接__objc_msgSend_uncached()。
  • 命中直接CacheHit \Mode，这里Mode为NORMAL。
• 平移获得p13 = buckets[mask]对应的元素，也就是最后一个元素（arm64下最后一个不存自身地址，也就相当于buckets[count - 1]）。
• p13 = buckets + mask << 4找到mask对应的buckets地址，地址平移找到对应bucket_t
• do-while循环扫描buckets[mask]的前面元素，直到index（不包含index）。
  • 命中CacheHit \Mode
  • 如果存在sel为空，则说明是没有缓存的，就直接结束循环。
• 最终仍然没有找到则执行__objc_msgSend_uncached()

1. CACHE是cache_t相对isa的偏移。 #define CACHE (2 * __SIZEOF_POINTER__)
2. maskZeroBits始终是4位0，p13 = buckets + (_bucketsAndMaybeMask >> 44)右移44位后就不用再<<4找到对应bucket_t的地址了。这是因为maskZeroBits在arm64_64下存在的原因。
3. f b 分别代表front与back，往下往上的意思。

1.2 CacheLookup 伪代码实现

LLookupPreopt\Function:

#if __has_feature(ptrauth_calls)

    //p10 = _bucketsAndMaybeMask & 0x007ffffffffffffe = buckets

    and p10, p11, #0x007ffffffffffffe   // p10 = x

    //buckets x16为cls 验证

    autdb   x10, x16            // auth as early as possible

#endif



    // x12 = (_cmd - first_shared_cache_sel)

    //(_cmd >> 12 + PAGE) << 12 + PAGEOFF 第一个sel

    adrp    x9, _MagicSelRef@PAGE

    ldr p9, [x9, _MagicSelRef@PAGEOFF]

    //差值index

    sub p12, p1, p9



    // w9  = ((_cmd - first_shared_cache_sel) >> hash_shift & hash_mask)

#if __has_feature(ptrauth_calls)

    // bits 63..60 of x11 are the number of bits in hash_mask

    // bits 59..55 of x11 is hash_shift



    // 取到 hash_shift...

    lsr x17, x11, #55           // w17 = (hash_shift, ...)

    //w9 = index >> hash_shift

    lsr w9, w12, w17            // >>= shift

    //x17 = _bucketsAndMaybeMask >>60 //mask_bits

    lsr x17, x11, #60           // w17 = mask_bits

    mov x11, #0x7fff

    //x11 = 0x7fff >> mask_bits //mask

    lsr x11, x11, x17           // p11 = mask (0x7fff >> mask_bits)

    //x9 = x9 & mask

    and x9, x9, x11         // &= mask

#else

    // bits 63..53 of x11 is hash_mask

    // bits 52..48 of x11 is hash_shift

    lsr x17, x11, #48           // w17 = (hash_shift, hash_mask)

    lsr w9, w12, w17            // >>= shift

    and x9, x9, x11, LSR #53        // &=  mask

#endif

    //x17 = el_offs | (imp_offs << 32)

    ldr x17, [x10, x9, LSL #3]      // x17 == sel_offs | (imp_offs << 32)

    // cmp x12  x17 是否找到sel

    cmp x12, w17, uxtw



.if \Mode == GETIMP

    b.ne    \MissLabelConstant      // cache miss

    //imp = isa - (sel_offs >> 32)

    sub x0, x16, x17, LSR #32       // imp = isa - imp_offs

    //注册imp

    SignAsImp x0

    ret

.else

    b.ne    5f              // cache miss

    //imp（x17） =  (isa - sel_offs>> 32)

    sub x17, x16, x17, LSR #32      // imp = isa - imp_offs

.if \Mode == NORMAL

    //跳转imp

    br  x17

.elseif \Mode == LOOKUP

    //x16 = isa | 3 //这里为或的意思

    orr x16, x16, #3 // for instrumentation, note that we hit a constant cache

    //注册imp

    SignAsImp x17

    ret

.else

.abort  unhandled mode \Mode

.endif

    //x9 = buckets-1

5:  ldursw  x9, [x10, #-8]          // offset -8 is the fallback offset

    //计算回调isa  x16 = x16 + x9

    add x16, x16, x9            // compute the fallback isa

    //使用新isa重新查找缓存

    b   LLookupStart\Function       // lookup again with a new isa

.endif

• 找到imp就跳转/返回。
• 没有找到返回下一个isa重新CacheLookup。
• 这块进入的查找共享缓存， 与cache_t的_originalPreoptCache有关。maskZeroBits这4位就是用来判断是否有_originalPreoptCache的。

⚠️@TODO 真机调试的时候进不到这块流程，这块分析的还不是很透彻，后面再补充。

三、CacheHit

在查找缓存命中后会执行CacheHit。

3.1 CacheHit源码分析

#define NORMAL 0

#define GETIMP 1

#define LOOKUP 2



// CacheHit: x17 = cached IMP, x10 = address of buckets, x1 = SEL, x16 = isa

.macro CacheHit

//这里传入的为NORMAL

.if $0 == NORMAL

    //调用imp TailCallCachedImp(imp,buckets,sel,isa)

    TailCallCachedImp x17, x10, x1, x16 // authenticate and call imp

.elseif $0 == GETIMP

    //返回imp

    mov p0, p17

    //imp == nil跳转9:

    cbz p0, 9f          // don't ptrauth a nil imp

    //有imp执行AuthAndResignAsIMP(imp,buckets,sel,isa)最后给到x0返回。

    AuthAndResignAsIMP x0, x10, x1, x16 // authenticate imp and re-sign as IMP

9:  ret             // return IMP

.elseif $0 == LOOKUP

    // No nil check for ptrauth: the caller would crash anyway when they

    // jump to a nil IMP. We don't care if that jump also fails ptrauth.

    //找imp(imp,buckets,sel,isa)

    AuthAndResignAsIMP x17, x10, x1, x16    // authenticate imp and re-sign as IMP

    //isa与x15比较

    cmp x16, x15

    //cinc如果相等 就将x16+1，否则就设成0.

    cinc    x16, x16, ne            // x16 += 1 when x15 != x16 (for instrumentation ; fallback to the parent class)

    ret             // return imp via x17

.else

.abort oops

.endif

.endmacro

• 这里其实走的是NORMAL逻辑，NORMAL的case直接验证并且跳转imp。
• TailCallCachedImp内部执行的是imp^cls，对imp进行了解码。
• GETIMP返回imp。
• LOOKUP查找注册imp并返回。

3.1 CacheHit伪代码实现

//x17 = cached IMP, x10 = address of buckets, x1 = SEL, x16 = isa

void CacheHit(Mode) {

    if (Mode == NORMAL) {

        //imp = imp^cls 解码

        TailCallCachedImp x17, x10, x1, x16    // 解码跳转imp

    } else if (Mode == GETIMP) {

        p0 = IMP

        if (p0 == nil) {

            return

        } else {

            AuthAndResignAsIMP(imp,buckets,sel,isa)//resign cached imp as IMP

        }

    } else if (Mode == LOOKUP) {

        AuthAndResignAsIMP(x17, buckets, sel, isa)//resign cached imp as IMP

        if (isa == x15) {

            x16 += 1

        } else {

            x16 = 0

        }

    } else {

        .abort oops//报错

    }

}

四、__objc_msgSend_uncached

在缓存没有命中的情况下会走到__objc_msgSend_uncached()的逻辑：

STATIC_ENTRY __objc_msgSend_uncached

UNWIND __objc_msgSend_uncached, FrameWithNoSaves



// THIS IS NOT A CALLABLE C FUNCTION

// Out-of-band p15 is the class to search

//查找imp

MethodTableLookup

//跳转imp

TailCallFunctionPointer x17



END_ENTRY __objc_msgSend_uncached

• MethodTableLookup查找imp
• TailCallFunctionPointer跳转imp

MethodTableLookup

.macro MethodTableLookup

    

    SAVE_REGS MSGSEND



    // lookUpImpOrForward(obj, sel, cls, LOOKUP_INITIALIZE | LOOKUP_RESOLVER)

    // receiver and selector already in x0 and x1

    //x2 = cls

    mov x2, x16

    //x3 = LOOKUP_INITIALIZE|LOOKUP_RESOLVER //是否初始化,imp没有实现尝试resolver

//_lookUpImpOrForward(receiver,selector,cls,LOOKUP_INITIALIZE | LOOKUP_RESOLVER)

    mov x3, #3

    bl  _lookUpImpOrForward



    // IMP in x0

    mov x17, x0



    RESTORE_REGS MSGSEND



.endmacro

• 调用_lookUpImpOrForward查找imp。这里就调用到了c/c++的代码了：

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)

最终会调用_lookUpImpOrForward进入c/c++环境逻辑。

对于架构的一些理解
LP64 //64位
x86_64 // interl 64位
i386 // intel 32位
arm // arm指令 32 位
arm64 //arm64指令
arm64 && LP64 //arm64 64位
arm64 && !LP64 //arm64 32 位

⚠️ 当然也可以通过真机跟踪汇编代码读取寄存器进行，与源码分析的是一致的，走其中的一个分支。

五、 objc_msgSend流程图

总结

• 判断receiver是否存在。
• 通过isa获取cls。
• cls内存平移0x10获取cache也就是_bucketsAndMaybeMask。
• 通过buckets & bucketsMask获取buckets`地址。
• 通过bucketsMask >> maskShift获取mask。
• 通过sel & mask获取第一次查找的index。
• buckets + index << 4找到index对应的地址。
• do-while循环判断找缓存，这次从[index～0]查找imp。
• 取到buckets[mask]继续do-while循环，从[mask~index)查找imp。两次查找过程中如果有sel为空则会结束查找。走__objc_msgSend_uncached的逻辑。
• 找到imp就解码跳转imp。

作者：HotPotCat
链接：https://www.jianshu.com/p/c29c07a1e93d

本文测试 demo 都是在 playground 里用 Swift5 完成的. 使用 GCD实现线程安全修改数据源, 示例中的读写都是对一个字典而言, 实际开发中可以是文件的读写(FileManager 是线程安全的), 可以是数组, 根据自己情况而定.

先来了解一下 GCD 中 队列 , 任务 , 线程, 同步, 异步 之间的关系 和 特点 :

• GCD 默认有两个队列 : 主队列 和 全局队列
• 主队列是特殊的串行队列, 主队列的任务一定在主线程执行.
• 全局队列就是普通的并发队列.
• 队列中的任务遵守先进先出规则, 即 FIFO.
• 队列只调试任务.
• 线程来执行任务.
• 同步执行不具有开启线程的能力
• 异步执行具有开启线程的能力, 但是不一定会开启新线程
• 并发队列允许开启新线程 .
• 串行队列不允许开启新线程的能力.
• 栅栏函数堵塞的是队列.

注意 : 主队列同步执行会造成死锁.

应用场景

• 1. 写
     开启多个任务去修改数据, 保证资源不被抢占. 比如买火车票, 多个窗口同时出票, 在服务器只能是一个一个来, 不能出现两个人同时买到同一个座位号的情况, 所以此时我们就需要保证数据安全, 即同一时间只能有一个任务去修改数据.
• 2. 读
     读操作可以允许多个任务同时加入队列, 但是要保证一个一个执行, 此处使用并发同步, 这么做是为了保证按照外部调用顺序去返回结果, 保证当前读操作完成后, 后面的操作才能进行. 其实是个假多读.

// 并发队列

var queue = DispatchQueue(label: "concurrent", attributes: .concurrent)

// 数据

var dictionary: [String: Any] = [:]



/// 数据初始化

func testInit() {

    dictionary = [

        "name": "Cooci",

        "age": 18,

        "girl": "xiaoxiannv"

    ]

}

/// 读的过程

func getSafeValueFor(_ key: String) -> Any? {

    var result: Any? = nil

    // 并发同步读取数据, 实际是假多读

    queue.sync {

        result = dictionary[key]

    }

    return result

}



/// 写的过程

func setSafe(_ value: Any, for key: String) {

    // 在子线程完成写任务

    // 等待前面任务执行完成后开始写

    // 写的完成任务后, 才能继续执行后边添加进此队列的任务

    queue.async(flags: .barrier) {

        dictionary[key] = value

    }

}

• 
source：事件源。
• start：控制计时器第一次触发的时刻。
  • 参数类型是 dispatch_time_t（opaque类型），不能直接操作它。需要 dispatch_time 和 dispatch_walltime 函数来创建。
  • 常量 DISPATCH_TIME_NOW 和 DISPATCH_TIME_FOREVER 很常用。
  • 当使用dispatch_time 或者 DISPATCH_TIME_NOW 时，系统会使用默认时钟来进行计时。然而当系统休眠的时候，默认时钟是不走的，也就会导致计时器停止。使用 dispatch_walltime 可以让计时器按照真实时间间隔进行计时。
• interval：回调间隔时间。
• leeway：计时器触发的精准程度，就算指定为0系统也无法保证完全精确的触发时间，只是会尽可能满足这个需求。

首先实现一个最简单的封装：

//忽略 handler 设置完马上回调

if (weakSelf.isAutoFirstCallback) {

    @synchronized(weakSelf) {

        weakSelf.isAutoFirstCallback = NO;

    }

    return;

}

//忽略挂起恢复后的立马回调

if (!weakSelf.resumeCallbackEnable && weakSelf.isResumeCallback) {

    @synchronized(weakSelf) {

        weakSelf.isResumeCallback = NO;

    }

    return;

}



if (handler) {

    handler();

}



if (!repeats) {

    //repeats 为 NO 执行一次后取消

    [weakSelf cancel];

}

为了更灵活对注册以及取消source逻辑也进行暴露：

dispatch_source_set_registration_handler(self.timer, ^{

    if (weakSelf.startBlock) {

        weakSelf.startBlock();

    }

});

//取消回调

dispatch_source_set_cancel_handler(self.timer, ^{

    if (weakSelf.cancelBlock) {

        weakSelf.cancelBlock();

    }

});

- (void)start {

    //为了与isResumeCallback区分开

    @synchronized(self) {

        if (!self.isStarted && self.timerStatus == HPTimerSuspend) {

            self.isStarted = YES;

            self.timerStatus = HPTimerResume;

            dispatch_resume(self.timer);

        }

    }

}



- (void)suspend {

    //挂起，挂起的时候不能设置timer为nil

    @synchronized(self) {

        if (self.timerStatus == HPTimerResume) {

            self.timerStatus = HPTimerSuspend;

            dispatch_suspend(self.timer);

        }

    }

}



- (void)resume {

    //恢复

    @synchronized(self) {

        if (self.timerStatus == HPTimerSuspend) {

            self.isResumeCallback = YES;

            self.timerStatus = HPTimerResume;

            dispatch_resume(self.timer);

        }

    }

}



- (void)cancel {

    //取消

    @synchronized(self) {

        if (self.timerStatus != HPTimerCanceled) {

            //先恢复再取消

            if (self.timerStatus == HPTimerSuspend) {

                [self resume];

            }

            self.timerStatus = HPTimerCanceled;

            dispatch_source_cancel(self.timer);

            _timer = nil;

        }

    }

}



- (void)dealloc {

    [self cancel];

}

• dealloc中主动进行cancel调用方可以不必在自己的dealloc中调用。

这样再暴露一些简单接口就可以直接调用了（调用方需要持有timer）：

self.timer = [HPTimer scheduledTimerWithTimeInterval:3 handler:^{

    NSLog(@"timer 回调");

}];

五、延迟函数(dispatch_after)

void

dispatch_after(dispatch_time_t when, dispatch_queue_t queue,

        dispatch_block_t work)

{

    _dispatch_after(when, queue, NULL, work, true);

}

直接调用_dispatch_after：

static inline void

_dispatch_after(dispatch_time_t when, dispatch_queue_t dq,

        void *ctxt, void *handler, bool block)

{

    dispatch_timer_source_refs_t dt;

    dispatch_source_t ds;

    uint64_t leeway, delta;

    //FOREVER 直接返回什么也不做

    if (when == DISPATCH_TIME_FOREVER) {

#if DISPATCH_DEBUG

        DISPATCH_CLIENT_CRASH(0, "dispatch_after called with 'when' == infinity");

#endif

        return;

    }



    delta = _dispatch_timeout(when);

    if (delta == 0) {

        if (block) {

            //时间为0直接执行handler

            return dispatch_async(dq, handler);

        }

        return dispatch_async_f(dq, ctxt, handler);

    }

    //精度 = 间隔 / 10

    leeway = delta / 10; // <rdar://problem/13447496>

    //<1 毫秒 的时候设置最小值为1毫秒

    if (leeway < NSEC_PER_MSEC) leeway = NSEC_PER_MSEC;

    //大于60s的时候设置为60s，也就是  1ms <= leeway <= 1min

    if (leeway > 60 * NSEC_PER_SEC) leeway = 60 * NSEC_PER_SEC;



    // this function can and should be optimized to not use a dispatch source

    //创建 type 为 after 的 source

    ds = dispatch_source_create(&_dispatch_source_type_after, 0, 0, dq);

    dt = ds->ds_timer_refs;



    dispatch_continuation_t dc = _dispatch_continuation_alloc();

    if (block) {

        //包装handler

        _dispatch_continuation_init(dc, dq, handler, 0, 0);

    } else {

        _dispatch_continuation_init_f(dc, dq, ctxt, handler, 0, 0);

    }

    // reference `ds` so that it doesn't show up as a leak

    dc->dc_data = ds;

    _dispatch_trace_item_push(dq, dc);

    //存储handler

    os_atomic_store2o(dt, ds_handler[DS_EVENT_HANDLER], dc, relaxed);

    dispatch_clock_t clock;

    uint64_t target;

    _dispatch_time_to_clock_and_value(when, false, &clock, &target);

    if (clock != DISPATCH_CLOCK_WALL) {

        leeway = _dispatch_time_nano2mach(leeway);

    }

    dt->du_timer_flags |= _dispatch_timer_flags_from_clock(clock);

    dt->dt_timer.target = target;

    dt->dt_timer.interval = UINT64_MAX;

    dt->dt_timer.deadline = target + leeway;

    dispatch_activate(ds);

}

1 start

1 end

2 start

2 end

3 start

3 end

4 start

4 end

2 start

2 end

1 start

1 end

/*

 * @param dsema

 * The semaphore. The result of passing NULL in this parameter is undefined.

*/



dispatch_semaphore_t

dispatch_semaphore_create(intptr_t value)

{

    dispatch_semaphore_t dsema;



    // If the internal value is negative, then the absolute of the value is

    // equal to the number of waiting threads. Therefore it is bogus to

    // initialize the semaphore with a negative value.

    if (value < 0) { //>=0 才有用，否则直接返回

        return DISPATCH_BAD_INPUT;// 0

    }



    dsema = _dispatch_object_alloc(DISPATCH_VTABLE(semaphore),

            sizeof(struct dispatch_semaphore_s));

    dsema->do_next = DISPATCH_OBJECT_LISTLESS;

    dsema->do_targetq = _dispatch_get_default_queue(false);

    dsema->dsema_value = value;

    _dispatch_sema4_init(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);

    dsema->dsema_orig = value;

    return dsema;

}

intptr_t

dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)

{

    //--

    long value = os_atomic_dec2o(dsema, dsema_value, acquire);

    if (likely(value >= 0)) { //>=0 返回

        return 0;

    }

    return _dispatch_semaphore_wait_slow(dsema, timeout);

}

DISPATCH_NOINLINE

static intptr_t

_dispatch_semaphore_wait_slow(dispatch_semaphore_t dsema,

        dispatch_time_t timeout)

{

    long orig;



    _dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);

    //超时直接break

    switch (timeout) {

    default:

        if (!_dispatch_sema4_timedwait(&dsema->dsema_sema, timeout)) {

            break;

        }

        // Fall through and try to undo what the fast path did to

        // dsema->dsema_value

    //NOW的情况下进行超时处理

    case DISPATCH_TIME_NOW:

        orig = dsema->dsema_value;

        while (orig < 0) {

            if (os_atomic_cmpxchgv2o(dsema, dsema_value, orig, orig + 1,

                    &orig, relaxed)) {

                return _DSEMA4_TIMEOUT();

            }

        }

        // Another thread called semaphore_signal().

        // Fall through and drain the wakeup.

    //FOREVER则进入wait逻辑。

    case DISPATCH_TIME_FOREVER:

        _dispatch_sema4_wait(&dsema->dsema_sema);

        break;

    }

    return 0;

}

#define _DSEMA4_TIMEOUT() KERN_OPERATION_TIMED_OUT

//    void

//    _dispatch_sema4_wait(_dispatch_sema4_t *sema)

//    {

//        int ret = 0;

//        do {

//            ret = sem_wait(sema);

//        } while (ret == -1 && errno == EINTR);

//        DISPATCH_SEMAPHORE_VERIFY_RET(ret);

//    }



void

_dispatch_sema4_wait(_dispatch_sema4_t *sema)

{

    kern_return_t kr;

    do {

        kr = semaphore_wait(*sema);

    } while (kr == KERN_ABORTED);

    DISPATCH_SEMAPHORE_VERIFY_KR(kr);

}

dispatch_async(queue, ^{

//  dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);

    do {

        //循环

    } while (signal <= 0);

    NSLog(@"1 start");

    NSLog(@"1 end");

});

/*!

 * @function dispatch_semaphore_signal

 *

 * @abstract

 * Signal (increment) a semaphore.

 *

 * @discussion

 * Increment the counting semaphore. If the previous value was less than zero,

 * this function wakes a waiting thread before returning.

 *

 * @param dsema The counting semaphore.

 * The result of passing NULL in this parameter is undefined.

 *

 * @result

 * This function returns non-zero if a thread is woken. Otherwise, zero is

 * returned.

 */

intptr_t

dispatch_semaphore_signal(dispatch_semaphore_t dsema)

{

    //++操作

    long value = os_atomic_inc2o(dsema, dsema_value, release);

    if (likely(value > 0)) {

        return 0;

    }

    //++ 后还 < 0，则表示做wait操作(--)过多。报错。

    if (unlikely(value == LONG_MIN)) {

        DISPATCH_CLIENT_CRASH(value,

                "Unbalanced call to dispatch_semaphore_signal()");

    }

    //发送信号量逻辑，恢复wait等待的操作。

    return _dispatch_semaphore_signal_slow(dsema);

}

intptr_t

_dispatch_semaphore_signal_slow(dispatch_semaphore_t dsema)

{

    _dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);

    _dispatch_sema4_signal(&dsema->dsema_sema, 1);

    return 1;

}

#define DISPATCH_SEMAPHORE_VERIFY_KR(x) do { \

        DISPATCH_VERIFY_MIG(x); \

        if (unlikely((x) == KERN_INVALID_NAME)) { \

            DISPATCH_CLIENT_CRASH((x), \

                "Use-after-free of dispatch_semaphore_t or dispatch_group_t"); \

        } else if (unlikely(x)) { \

            DISPATCH_INTERNAL_CRASH((x), "mach semaphore API failure"); \

        } \

    } while (0)



//经过调试走的是这个逻辑

void

_dispatch_sema4_signal(_dispatch_sema4_t *sema, long count)

{

    do {

        kern_return_t kr = semaphore_signal(*sema);//+1

        DISPATCH_SEMAPHORE_VERIFY_KR(kr);// == -1 报错

    } while (--count);//do-while(0) 只执行一次

}

dispatch_group_t group = dispatch_group_create();

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);



dispatch_group_async(group, queue, ^{

    sleep(3);

    NSLog(@"1");

});



dispatch_group_async(group, queue1, ^{

    sleep(2);

    NSLog(@"2");

});



dispatch_group_async(group, queue1, ^{

    sleep(1);

    NSLog(@"3");

});



dispatch_group_async(group, queue, ^{

    NSLog(@"4");

});



dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{

    NSLog(@"5");

});

dispatch_group_t group = dispatch_group_create();

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);



//先 enter 再 leave

dispatch_group_enter(group);

dispatch_async(queue, ^{

    sleep(3);

    NSLog(@"1");

    dispatch_group_leave(group);

});



dispatch_group_enter(group);

dispatch_async(queue1, ^{

    sleep(2);

    NSLog(@"2");

    dispatch_group_leave(group);

});



dispatch_group_enter(group);

dispatch_async(queue1, ^{

    sleep(1);

    NSLog(@"3");

    dispatch_group_leave(group);

});



dispatch_group_enter(group);

dispatch_async(queue, ^{

    NSLog(@"4");

    dispatch_group_leave(group);

});



dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{

    NSLog(@"5");

});

dispatch_group_t

dispatch_group_create(void)

{

    return _dispatch_group_create_with_count(0);

}



//creat & enter 写在一起的写法，信号量标记位1

dispatch_group_t

_dispatch_group_create_and_enter(void)

{

    return _dispatch_group_create_with_count(1);

}

static inline dispatch_group_t

_dispatch_group_create_with_count(uint32_t n)

{

    dispatch_group_t dg = _dispatch_object_alloc(DISPATCH_VTABLE(group),

            sizeof(struct dispatch_group_s));

    dg->do_next = DISPATCH_OBJECT_LISTLESS;

    dg->do_targetq = _dispatch_get_default_queue(false);

    if (n) {

        os_atomic_store2o(dg, dg_bits,

                (uint32_t)-n * DISPATCH_GROUP_VALUE_INTERVAL, relaxed);

        os_atomic_store2o(dg, do_ref_cnt, 1, relaxed); // <rdar://22318411>

    }

    return dg;

}

void

dispatch_group_enter(dispatch_group_t dg)

{

    // The value is decremented on a 32bits wide atomic so that the carry

    // for the 0 -> -1 transition is not propagated to the upper 32bits.

    //0-- -> -1，与信号量不同的是没有wait

    uint32_t old_bits = os_atomic_sub_orig2o(dg, dg_bits,

            DISPATCH_GROUP_VALUE_INTERVAL, acquire);

    uint32_t old_value = old_bits & DISPATCH_GROUP_VALUE_MASK;

    if (unlikely(old_value == 0)) {

        _dispatch_retain(dg); // <rdar://problem/22318411>

    }

    if (unlikely(old_value == DISPATCH_GROUP_VALUE_MAX)) {

        DISPATCH_CLIENT_CRASH(old_bits,

                "Too many nested calls to dispatch_group_enter()");

    }

}

void

dispatch_group_leave(dispatch_group_t dg)

{

    // The value is incremented on a 64bits wide atomic so that the carry for

    // the -1 -> 0 transition increments the generation atomically.

    //-1++ -> 0

    uint64_t new_state, old_state = os_atomic_add_orig2o(dg, dg_state,

            DISPATCH_GROUP_VALUE_INTERVAL, release);

    //#define DISPATCH_GROUP_VALUE_MASK       0x00000000fffffffcULL

    // old_state & DISPATCH_GROUP_VALUE_MASK 是一个很大的值

    uint32_t old_value = (uint32_t)(old_state & DISPATCH_GROUP_VALUE_MASK);

    //-1 & DISPATCH_GROUP_VALUE_MASK == DISPATCH_GROUP_VALUE_1，old_value = -1

    if (unlikely(old_value == DISPATCH_GROUP_VALUE_1)) {//old_value == -1

        old_state += DISPATCH_GROUP_VALUE_INTERVAL;

        do {

            new_state = old_state;

            if ((old_state & DISPATCH_GROUP_VALUE_MASK) == 0) {

                new_state &= ~DISPATCH_GROUP_HAS_WAITERS;

                new_state &= ~DISPATCH_GROUP_HAS_NOTIFS;

            } else {

                // If the group was entered again since the atomic_add above,

                // we can't clear the waiters bit anymore as we don't know for

                // which generation the waiters are for

                new_state &= ~DISPATCH_GROUP_HAS_NOTIFS;

            }

            if (old_state == new_state) break;

        } while (unlikely(!os_atomic_cmpxchgv2o(dg, dg_state,

                old_state, new_state, &old_state, relaxed)));

        //调用 _dispatch_group_wake，唤醒 dispatch_group_notify

        return _dispatch_group_wake(dg, old_state, true);

    }

    //old_value 为0的情况下直接报错，也就是先leave的情况下直接报错

    if (unlikely(old_value == 0)) {

        DISPATCH_CLIENT_CRASH((uintptr_t)old_value,

                "Unbalanced call to dispatch_group_leave()");

    }

}

void

dispatch_group_notify(dispatch_group_t dg, dispatch_queue_t dq,

        dispatch_block_t db)

{

    dispatch_continuation_t dsn = _dispatch_continuation_alloc();

    _dispatch_continuation_init(dsn, dq, db, 0, DC_FLAG_CONSUME);

    _dispatch_group_notify(dg, dq, dsn);

}

static inline void

_dispatch_group_notify(dispatch_group_t dg, dispatch_queue_t dq,

        dispatch_continuation_t dsn)

{

    uint64_t old_state, new_state;

    dispatch_continuation_t prev;



    dsn->dc_data = dq;

    _dispatch_retain(dq);



    prev = os_mpsc_push_update_tail(os_mpsc(dg, dg_notify), dsn, do_next);

    if (os_mpsc_push_was_empty(prev)) _dispatch_retain(dg);

    os_mpsc_push_update_prev(os_mpsc(dg, dg_notify), prev, dsn, do_next);

    if (os_mpsc_push_was_empty(prev)) {

        os_atomic_rmw_loop2o(dg, dg_state, old_state, new_state, release, {

            new_state = old_state | DISPATCH_GROUP_HAS_NOTIFS;

            if ((uint32_t)old_state == 0) {//循环判断 old_state == 0 的时候 wake

                os_atomic_rmw_loop_give_up({

                    return _dispatch_group_wake(dg, new_state, false);

                });

            }

        });

    }

}

static void

_dispatch_group_wake(dispatch_group_t dg, uint64_t dg_state, bool needs_release)

{

    uint16_t refs = needs_release ? 1 : 0; // <rdar://problem/22318411>



    if (dg_state & DISPATCH_GROUP_HAS_NOTIFS) {

        dispatch_continuation_t dc, next_dc, tail;



        // Snapshot before anything is notified/woken <rdar://problem/8554546>

        dc = os_mpsc_capture_snapshot(os_mpsc(dg, dg_notify), &tail);

        do {

            dispatch_queue_t dsn_queue = (dispatch_queue_t)dc->dc_data;

            next_dc = os_mpsc_pop_snapshot_head(dc, tail, do_next);

            //异步回调，执行block callout

            _dispatch_continuation_async(dsn_queue, dc,

                    _dispatch_qos_from_pp(dc->dc_priority), dc->dc_flags);

            _dispatch_release(dsn_queue);

        } while ((dc = next_dc));



        refs++;

    }



    if (dg_state & DISPATCH_GROUP_HAS_WAITERS) {

        _dispatch_wake_by_address(&dg->dg_gen);

    }



    if (refs) _dispatch_release_n(dg, refs);

}

dispatch_group_async(dispatch_group_t dg, dispatch_queue_t dq,

        dispatch_block_t db)

{

    dispatch_continuation_t dc = _dispatch_continuation_alloc();

       //标记 DC_FLAG_GROUP_ASYNC

    uintptr_t dc_flags = DC_FLAG_CONSUME | DC_FLAG_GROUP_ASYNC;

    dispatch_qos_t qos;



    qos = _dispatch_continuation_init(dc, dq, db, 0, dc_flags);

    _dispatch_continuation_group_async(dg, dq, dc, qos);

}

static inline void

_dispatch_continuation_group_async(dispatch_group_t dg, dispatch_queue_t dq,

        dispatch_continuation_t dc, dispatch_qos_t qos)

{

    //调用enter

    dispatch_group_enter(dg);

    dc->dc_data = dg;

    //dispatch_async

    _dispatch_continuation_async(dq, dc, qos, dc->dc_flags);

}

static inline void

_dispatch_continuation_with_group_invoke(dispatch_continuation_t dc)

{

    struct dispatch_object_s *dou = dc->dc_data;

    unsigned long type = dx_type(dou);

    if (type == DISPATCH_GROUP_TYPE) {

        //callout

        _dispatch_client_callout(dc->dc_ctxt, dc->dc_func);

        _dispatch_trace_item_complete(dc);

        //leave

        dispatch_group_leave((dispatch_group_t)dou);

    } else {

        DISPATCH_INTERNAL_CRASH(dx_type(dou), "Unexpected object type");

    }

}

一、栅栏函数

CPU的乱序执行能力让我们对多线程的安全保障的努力变得异常困难。因此要保证线程安全，阻止CPU换序是必需的。遗憾的是，现在并不存在可移植的阻止换序的方法。通常情况下是调用CPU提供的一条指令，这条指令常常被称为barrier。一条barrier指令会阻止CPU将该指令之前的指令交换到barrier之后，反之亦然。换句话说，barrier指令的作用类似于一个拦水坝，阻止换序穿透这个大坝。

栅栏函数最直接的作用：控制任务执行顺序，导致同步效果。
有两个函数：

• dispatch_barrier_async：前面的任务执行完毕才会执行barrier中的逻辑，以及barrier后加入队列的任务。
• dispatch_barrier_sync：作用相同，但是会堵塞线程，影响后面的任务执行 。

⚠️：栅栏函数只能控制同一队列并发，相当于针对队列而言。

1.1 应用

1.1.1 dispatch_barrier_async 与 dispatch_barrier_sync 效果

有如下案例：

- (void)test {

    dispatch_queue_t concurrentQueue = dispatch_queue_create("HotpotCat", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(concurrentQueue, ^{

        sleep(3);

        NSLog(@"1");

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"2");

    });

    dispatch_barrier_async(concurrentQueue, ^{

        NSLog(@"3:%@",[NSThread currentThread]);

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"4");

    });

    NSLog(@"5");

}

分析：barrier阻塞的是自己以及concurrentQueue队列中在它后面加入的任务。由于这里使用的是异步函数所以任务1，2，5顺序不定，3在4之前。
输出：

GCDDemo[49708:5622304] 5

GCDDemo[49708:5622437] 2

GCDDemo[49708:5622434] 1

GCDDemo[49708:5622434] 3:<NSThread: 0x600003439040>{number = 6, name = (null)}

GCDDemo[49708:5622434] 4

dispatch_queue_t concurrentQueue = dispatch_get_global_queue(0, 0);

dispatch_async(concurrentQueue, ^{

    NSLog(@"1");

});

dispatch_async(concurrentQueue, ^{

    NSLog(@"2");

});

dispatch_barrier_async(concurrentQueue, ^{

    NSLog(@"3:%@",[NSThread currentThread]);

});

dispatch_async(concurrentQueue, ^{

    NSLog(@"4");

});

NSLog(@"5");

GCDDemo[49872:5632760] 5

GCDDemo[49872:5632979] 1

GCDDemo[49872:5633673] 2

GCDDemo[49872:5633675] 4

GCDDemo[49872:5633674] 3:<NSThread: 0x600001160240>{number = 10, name = (null)}

dispatch_queue_t concurrentQueue = dispatch_queue_create("Hotpot", DISPATCH_QUEUE_CONCURRENT);

dispatch_queue_t concurrentQueue2 = dispatch_queue_create("Cat", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(concurrentQueue, ^{

    sleep(3);

    NSLog(@"1");

});

dispatch_async(concurrentQueue2, ^{

    NSLog(@"2");

});

dispatch_barrier_async(concurrentQueue, ^{

    NSLog(@"3:%@",[NSThread currentThread]);

});

dispatch_async(concurrentQueue2, ^{

    NSLog(@"4");

});

NSLog(@"5");

GCDDemo[49981:5639766] 5

GCDDemo[49981:5640003] 2

GCDDemo[49981:5639998] 4

GCDDemo[49981:5639997] 1

GCDDemo[49981:5639998] 3:<NSThread: 0x600003761500>{number = 5, name = (null)}

NSMutableArray *array = [NSMutableArray array];

dispatch_queue_t concurrentQueue = dispatch_queue_create("Hotpot", DISPATCH_QUEUE_CONCURRENT);

for (int i = 0; i < 1000; i++) {

    dispatch_async(concurrentQueue, ^{

        [array addObject:@(i)];

    });

}

NSMutableArray *array = [NSMutableArray array];

dispatch_queue_t concurrentQueue = dispatch_queue_create("Hotpot", DISPATCH_QUEUE_CONCURRENT);

for (int i = 0; i < 1000; i++) {

    dispatch_async(concurrentQueue, ^{

        dispatch_barrier_async(concurrentQueue , ^{

            [array addObject:@(i)];

        });

    });

}

void

dispatch_barrier_sync(dispatch_queue_t dq, dispatch_block_t work)

{

    uintptr_t dc_flags = DC_FLAG_BARRIER | DC_FLAG_BLOCK;

    if (unlikely(_dispatch_block_has_private_data(work))) {

        return _dispatch_sync_block_with_privdata(dq, work, dc_flags);

    }

    _dispatch_barrier_sync_f(dq, work, _dispatch_Block_invoke(work), 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);

}

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;



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

}

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

    }

    ......

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

}

static void

_dispatch_sync_complete_recurse(dispatch_queue_t dq, dispatch_queue_t stop_dq,

        uintptr_t dc_flags)

{

    bool barrier = (dc_flags & DC_FLAG_BARRIER);

    do {

        if (dq == stop_dq) return;

        if (barrier) {

            //唤醒执行

            //_dispatch_lane_wakeup

            dx_wakeup(dq, 0, DISPATCH_WAKEUP_BARRIER_COMPLETE);

        } else {

            //已经执行完成没有栅栏函数

            _dispatch_lane_non_barrier_complete(upcast(dq)._dl, 0);

        }

        dq = dq->do_targetq;

        barrier = (dq->dq_width == 1);

    } while (unlikely(dq->do_targetq));

}

void

_dispatch_lane_wakeup(dispatch_lane_class_t dqu, dispatch_qos_t qos,

        dispatch_wakeup_flags_t flags)

{

    dispatch_queue_wakeup_target_t target = DISPATCH_QUEUE_WAKEUP_NONE;



    if (unlikely(flags & DISPATCH_WAKEUP_BARRIER_COMPLETE)) {

        //barrier完成了就走这里的逻辑,barrier之前的任务执行完毕。

        return _dispatch_lane_barrier_complete(dqu, qos, flags);

    }

    if (_dispatch_queue_class_probe(dqu)) {

        target = DISPATCH_QUEUE_WAKEUP_TARGET;

    }

    //走这里

    return _dispatch_queue_wakeup(dqu, qos, flags, target);

}

void

_dispatch_queue_wakeup(dispatch_queue_class_t dqu, dispatch_qos_t qos,

        dispatch_wakeup_flags_t flags, dispatch_queue_wakeup_target_t target)

{

......



    if (likely((old_state ^ new_state) & enqueue)) {

......

        //_dispatch_queue_push_queue 断点断不住，走这里。

        return _dispatch_queue_push_queue(tq, dq, new_state);

    }

......

}

static inline void

_dispatch_queue_push_queue(dispatch_queue_t tq, dispatch_queue_class_t dq,

        uint64_t dq_state)

{

#if DISPATCH_USE_KEVENT_WORKLOOP

    if (likely(_dq_state_is_base_wlh(dq_state))) {

        _dispatch_trace_runtime_event(worker_request, dq._dq, 1);

        return _dispatch_event_loop_poke((dispatch_wlh_t)dq._dq, dq_state,

                DISPATCH_EVENT_LOOP_CONSUME_2);

    }

#endif // DISPATCH_USE_KEVENT_WORKLOOP

    _dispatch_trace_item_push(tq, dq);

    //_dispatch_lane_concurrent_push

    return dx_push(tq, dq, _dq_state_max_qos(dq_state));

}

void

_dispatch_lane_concurrent_push(dispatch_lane_t dq, dispatch_object_t dou,

        dispatch_qos_t qos)

{

    if (dq->dq_items_tail == NULL &&

            !_dispatch_object_is_waiter(dou) &&

            !_dispatch_object_is_barrier(dou) &&

            _dispatch_queue_try_acquire_async(dq)) {

        return _dispatch_continuation_redirect_push(dq, dou, qos);

    }



    _dispatch_lane_push(dq, dou, qos);

}

void

_dispatch_lane_push(dispatch_lane_t dq, dispatch_object_t dou,

        dispatch_qos_t qos)

{

......

    if (flags) {

        //栅栏函数走这里。

        //#define dx_wakeup(x, y, z) dx_vtable(x)->dq_wakeup(x, y, z)

        //dx_wakeup 对应 dq_wakeup 自定义全局队列对应 _dispatch_lane_wakeup，全局队列对应 _dispatch_root_queue_wakeup

        return dx_wakeup(dq, qos, flags);

    }

}

open func lock(whenCondition condition: Int, before limit: Date) -> Bool {

    _cond.lock()

    while _thread != nil || _value != condition {

        if !_cond.wait(until: limit) {

            _cond.unlock()

            return false

        }

    }

    _thread = pthread_self()

    _cond.unlock()

    return true

}

• lockWhenCondition：

-(int)lockWhenCondition:(int)arg2 {

    r0 = [arg0 lockWhenCondition:arg2 beforeDate:[NSDate distantFuture]];

    return r0;

}

调用自己的lockWhenCondition: beforeDate :：

unlockWithCondition

-(int)unlockWithCondition:(int)arg2 {

    r0 = object_getIndexedIvars(arg0);

    [*r0 lock];

    *(int128_t *)(r0 + 0x8) = 0x0;

    *(int128_t *)(r0 + 0x10) = arg2;

    [*r0 broadcast];

    r0 = *r0;

    r0 = [r0 unlock];

    return r0;

}

int -[NSConditionLock lock](int arg0) {

    r0 = [arg0 lockBeforeDate:[NSDate distantFuture]];

    return r0;

}

int -[NSConditionLock unlock]() {

    r0 = object_getIndexedIvars(r0);

    [*r0 lock];

    *(r0 + 0x8) = 0x0;

    [*r0 broadcast];

    r0 = *r0;

    r0 = [r0 unlock];

    return r0;

}

OSSpinLock hp_spinlock = OS_SPINLOCK_INIT;

OSSpinLockLock(&hp_spinlock);

OSSpinLockUnlock(&hp_spinlock);

typedef int32_t OSSpinLock OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock);



#define OS_SPINLOCK_INIT    0

void

OSSpinLockLock(volatile OSSpinLock *l)

{

    OS_ATOMIC_ALIAS(spin_lock, OSSpinLockLock);

    OS_ATOMIC_ALIAS(_spin_lock, OSSpinLockLock);

    bool r = os_atomic_cmpxchg(l, 0, _OSSpinLockLocked, acquire);

    if (likely(r)) return;

    return _OSSpinLockLockSlow(l);

}



#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR

static const OSSpinLock _OSSpinLockLocked = 1;

#else

static const OSSpinLock _OSSpinLockLocked = -1;

#endif

#undef OS_ATOMIC_ALIAS

#define OS_ATOMIC_ALIAS(n, o)

static void _OSSpinLockLock(volatile OSSpinLock *l);

#if OS_ATOMIC_UP

void

_OSSpinLockLockSlow(volatile OSSpinLock *l)

{

    return _OSSpinLockLockYield(l); // Don't spin on UP

}

#elif defined(__arm64__)

// Exclusive monitor must be held during WFE <rdar://problem/22300054>

#if defined(__ARM_ARCH_8_2__)

void

_OSSpinLockLockSlow(volatile OSSpinLock *l)

{

    uint32_t tries = OS_LOCK_SPIN_SPIN_TRIES;

    OSSpinLock lock;

_spin:

    while (unlikely(lock = os_atomic_load_exclusive(l, relaxed))) {

        if (unlikely(lock != _OSSpinLockLocked)) {

            os_atomic_clear_exclusive();

            return _os_lock_corruption_abort((void *)l, (uintptr_t)lock);

        }

        if (unlikely(!tries--)) {

            os_atomic_clear_exclusive();

            return _OSSpinLockLockYield(l);

        }

        OS_LOCK_SPIN_PAUSE();

    }

    os_atomic_clear_exclusive();

    bool r = os_atomic_cmpxchg(l, 0, _OSSpinLockLocked, acquire);

    if (likely(r)) return;

    goto _spin;

}

#else // !__ARM_ARCH_8_2__

void

_OSSpinLockLockSlow(volatile OSSpinLock *l)

{

    uint32_t tries = OS_LOCK_SPIN_SPIN_TRIES;

    OSSpinLock lock;

    os_atomic_rmw_loop(l, lock, _OSSpinLockLocked, acquire, if (unlikely(lock)){

        if (unlikely(lock != _OSSpinLockLocked)) {

            os_atomic_rmw_loop_give_up(return

                    _os_lock_corruption_abort((void *)l, (uintptr_t)lock));

        }

        if (unlikely(!tries--)) {

            os_atomic_rmw_loop_give_up(return _OSSpinLockLockYield(l));

        }

        OS_LOCK_SPIN_PAUSE();

        continue;

    });

}

#endif // !__ARM_ARCH_8_2__

#else // !OS_ATOMIC_UP

void

_OSSpinLockLockSlow(volatile OSSpinLock *l)

{

    uint32_t tries = OS_LOCK_SPIN_SPIN_TRIES;

    OSSpinLock lock;

    while (unlikely(lock = *l)) {

_spin:

        if (unlikely(lock != _OSSpinLockLocked)) {

            return _os_lock_corruption_abort((void *)l, (uintptr_t)lock);

        }

        if (unlikely(!tries--)) return _OSSpinLockLockYield(l);

        OS_LOCK_SPIN_PAUSE();

    }

    bool r = os_atomic_cmpxchgv(l, 0, _OSSpinLockLocked, &lock, acquire);

    if (likely(r)) return;

    goto _spin;

}

#endif // !OS_ATOMIC_UP