前沿
队列的本质是对象,在我们使用GCD创建队列时，创建好的队列主要是记录并发或者串行等信息，如果需要完成任务则需要被函数调用。下面就从底层探索这些函数
我们可以在官网上下载libdispatch,如果在libdispatch中有多个判断，我们怎么确定走的哪个判断呢？我们就可以下符号断点验证。下面的确定的流程图好多都是通过下符号断点确定到底走哪个if else的。
1.同步和死锁
串行
死锁
死锁发生在串行队列同步执行，我们可以在主线程中同步主队列，看一下堆栈信息。
NSLog(@"1234");
});
bt后的堆栈信息
* thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)
frame #0: 0x00000001046d206c libdispatch.dylib`__DISPATCH_WAIT_FOR_QUEUE__ + 444
frame #1: 0x00000001046d1a43 libdispatch.dylib`_dispatch_sync_f_slow + 231
* frame #2: 0x0000000104450123 001---函数与队列`-[ViewController viewDidLoad](self=0x00007f8c41706ea0,
static inline bool
_dispatch_lock_is_locked_by(dispatch_lock lock_value, dispatch_tid tid)
{
// equivalent to _dispatch_lock_owner(lock_value) == tid
return ((lock_value ^ tid) & DLOCK_OWNER_MASK) == 0;
}
_dispatch_lock_is_locked_by主要是判断被锁的线程和当前线程是否为同一个线程，如果是同一个线程则会在DISPATCH_WAIT_FOR_QUEUE 中CRASH
并发
2.异步
并发
我们着重看一下_dispatch_root_queue_poke_slow
_dispatch_retain(dq); // released in _dispatch_worker_thread
while ((r = pthread_create(pthr, attr, _dispatch_worker_thread, dq))) {
if (r != EAGAIN) {
(void)dispatch_assume_zero(r);
}
_dispatch_temporary_resource_shortage();
}
对线程的创建的
在什么时候调用异步中的block呢？我们通过堆栈信息查看一下
dispatch_queue_t concurrentqueue = dispatch_queue_create("my.con", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentqueue, ^{
NSLog(@"1234");
});
(lldb) bt
viewDidLoad]_block_invoke(.block_descriptor=0x0000000106c2e0f0) at ViewController.m:23:9
frame #1: 0x0000000106e9c8ac libdispatch.dylib`_dispatch_call_block_and_release + 12
frame #2: 0x0000000106e9da88 libdispatch.dylib`_dispatch_client_callout + 8
frame #3: 0x0000000106ea03d6 libdispatch.dylib`_dispatch_continuation_pop + 557
frame #4: 0x0000000106e9f7dc libdispatch.dylib`_dispatch_async_redirect_invoke + 779
frame #5: 0x0000000106eaf5b6 libdispatch.dylib`_dispatch_root_queue_drain + 351
frame #6: 0x0000000106eaff1b libdispatch.dylib`_dispatch_worker_thread2 + 135
我们看一下_dispatch_root_queues_init中_dispatch_worker_thread2===>_dispatch_root_queue_drain===>_dispatch_continuation_pop_inline==>dx_invoke==> _dispatch_async_redirect_invoke===>_dispatch_continuation_pop===>_dispatch_continuation_pop_inline=====>_dispatch_client_callout
3.栅栏
栅栏只能用自建的并发队列
dispatch_barrier_async===>_dispatch_continuation_async===>_dispatch_lane_concurrent_push====>_dispatch_lane_push===>_dispatch_lane_push_waiter
4.信号量
dispatch_semaphore_t sepahore=dispatch_semaphore_create(1);
dispatch_queue_t queue = dispatch_queue_create("1234", DISPATCH_QUEUE_CONCURRENT);
__block int i = 0;
while (i<5) {
dispatch_semaphore_wait(sepahore, DISPATCH_TIME_FOREVER);
dispatch_async(queue, ^{
sleep(2);
I++;
NSLog(@"内部的%d",i);
dispatch_semaphore_signal(sepahore);
});
}
打印结果
2020-11-09 15:03:53.656294+0800 001---函数与队列[19344:6787567] 内部的1
2020-11-09 15:03:55.658937+0800 001---函数与队列[19344:6787567] 内部的2
2020-11-09 15:03:57.664476+0800 001---函数与队列[19344:6787567] 内部的3
2020-11-09 15:03:59.668310+0800 001---函数与队列[19344:6787567] 内部的4
2020-11-09 15:04:01.672977+0800 001---函数与队列[19344:6787567] 内部的5
2020-11-09 15:04:03.677596+0800 001---函数与队列[19344:6787567] 内部的6
信号量到底做了什么呢？让我们一块探究GCD的实现
1.dispatch_semaphore_create(long value)
创建一个OS_dispatch_semaphore的对象，里面保存我们设置的value值。如果value小于0，返回0
2.dispatch_semaphore_wait
对保存的value值先进行减1，如果value值大于等于0，则正常执行，如果小于0则
_dispatch_semaphore_wait_slow等待.
DISPATCH_TIME_NOW立即执行，DISPATCH_TIME_FOREVER如果不满足条件会等待。
3.dispatch_semaphore_signal
对保存的value值进行加1，如果value大于0，则正常执行，
5.单例
dispatch_once===>_dispatch_once==>（源码中的）dispatch_once===>dispatch_once_f
void
dispatch_once_f(dispatch_once_t *val, void *ctxt, dispatch_function_t func)
{
dispatch_once_gate_t l = (dispatch_once_gate_t)val;
#if !DISPATCH_ONCE_INLINE_FASTPATH || DISPATCH_ONCE_USE_QUIESCENT_COUNTER
uintptr_t v = os_atomic_load(&l->dgo_once, acquire);
if (likely(v == DLOCK_ONCE_DONE)) {
return;
}
#if DISPATCH_ONCE_USE_QUIESCENT_COUNTER
if (likely(DISPATCH_ONCE_IS_GEN(v))) {
return _dispatch_once_mark_done_if_quiesced(l, v);
}
#endif
#endif
if (_dispatch_once_gate_tryenter(l)) {
return _dispatch_once_callout(l, ctxt, func);
}
return _dispatch_once_wait(l);
}
_dispatch_once_gate_tryenter判断，确定没有被加锁,状态是DLOCK_ONCE_UNLOCKED
通过符号断点可知，_dispatch_once_callout，调用block，并调用_dispatch_once_gate_broadcast进行广播并设置DLOCK_ONCE_DONE状态。
如果在没有实例化完成时，有其他调用单例，则走_dispatch_once_wait会死循环，直到前面单例完成。
调度组
dispatch_queue_t concurrentqueue = dispatch_queue_create("my.con", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t group = dispatch_group_create();
dispatch_group_enter(group);
dispatch_async(concurrentqueue, ^{
sleep(2);
NSLog(@"1234");
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(concurrentqueue, ^{
sleep(2);
NSLog(@"234");
dispatch_group_leave(group);
});
dispatch_group_notify(group, concurrentqueue, ^{
NSLog(@"执行结束了");
});
打印结果
2020-11-09 17:09:07.973422+0800 001---函数与队列[91778:7107224] 1234
2020-11-09 17:09:07.973422+0800 001---函数与队列[91778:7107227] 234
2020-11-09 17:09:07.973692+0800 001---函数与队列[91778:7107227] 执行结束了
1.创建调度组dispatch_group_create
dispatch_group_create====>_dispatch_group_create_with_count(0)====>创建dispatch_group_t对象。group的value值为0
2.入组 dispatch_group_enter(group);
对group的value值减1，如果值为0则组进行retain一般不会出现这种情况。
3.出组dispatch_group_leave(group)
对group的value值加1，如果group成对出现则会唤醒dispatch_group_notify内的block
4.dispatch_group_async
dispatch_group_async====>_dispatch_continuation_group_async====>dispatch_group_enter,入组。
调用dispatch_group_asyncblock时
_dispatch_continuation_pop===》_dispatch_continuation_pop_inline====>_dispatch_continuation_invoke_inline======>_dispatch_continuation_with_group_invoke=====>dispatch_group_leave
dispatch_group_async实际上是内部实现了dispatch_group_enter和dispatch_group_leave。
补充Dispatch_Source
dispatch_source_create 创建源
dispatch_source_set_event_handler 设置源事件回调
dispatch_source_merge_data 源事件设置数据
dispatch_source_set_timer源事件设置颜色
dispatch_source_get_data 获取源事件数据
dispatch_resume 继续
dispatch_suspend 挂起
下面计时器的核心代码
self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_global_queue(0, 0 ));
dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));
dispatch_source_set_timer(self.timer, start, (uint64_t)(1.0 * NSEC_PER_SEC), 0);
dispatch_source_set_event_handler(self.timer, ^{
});
dispatch_resume(self.timer);
