sync同步函数serial串行队列:不会开启线程，在当前线程执行任务，会产生堵塞
sync同步函数Concurrent并发队列:不会开启线程，任务一个接着一个，不会产生堵塞
async异步函数serial串行队列:开启线程一条新线程，任务一个接着一个
async异步函数Concurrent并发队列:开启线程，在当前线程执行任务，任务异步执行，没有顺序与cpu调度有关
同步:等待 1 串行:等待 1
主队列:专门用来在线程上调度任务的串行队列,不会开启线程,如果当前主线程有任务正在执行那么主队列的任务都不会被调度
全局队列:一个并发队列，且不能被栅栏函数作用，在使用多线程开发时，如果没有特殊需求，执行异步任务，默认使用全局队列
注释:DISPATH_QUEUE_WIDTH_FULL 0x1000ull
dispath_async(queue_t dq,block_t work){
1.申请空间 continuation
2.初始化init
dispath_continuation_init(dc,dq,work,0,dc_flags){
dc：申请的空间
dq：当前队列
work：任务
flags：标识
dispatch_function_t func = dispatch_Block_invoke(work)->dispatch_call_block_and_release(ctxt)
dc->dc_ctxt = ctxt (dc内的属性是alloc出来的)
dc->dc_func = f
qos= init_f(dc,dqu,ctxt,func,flags,dc_flags)
dispatch_continuation_async(dq,dc,qos,dc->dc_flags)
pop_inline-(dispatch_object_t dou )
}
GCD-单例
单例dispatch_once(dispatch_once_t *val ,ctxt,func){
dispatch_once_gate_t l=val;
1.v = os_atomic_load(&l->dgo_once,acquire)
2.if v==DLOCK_ONCE_DONE ->return
tryenter(l){加锁
3.os_atomic_cmpxchg(&l->dog_once,DLOCK_ONCE_UNLOCKED,lock_value_for_self,relaxed)
4.dispatch_once_callout(l,ctxt,func){gate_broadcast(l) 对已经调用的单例l进行广播}
}
5.broadcast(dispatch_once_gate_t l){
6.dispatch_lock value_self = _dispatch_lock_value_for_self();上一步比较cmp操作用到的参数,作用是修改v值，使下次再无法再次调用单例
7.v = dispatch_once_mark_done(l) //单例作用已完成 标记mark .v返回给os_atomic_load
{
8.return os_atomic_xchg(&dgo->dgo_once,DLOCK_ONCE_DONE,release)这个就是V返回给2
}
}
return once_wait(l)
}
GCD-栅栏函数(barrier)
dispatch_barrier_async(异步) 阻塞队列
dispatch_barrier_sync(同步) 阻塞线程
注释：栅栏函数只能传入一个自己创建的并发队列
GCD-同步函数
dispatch_sync_f_inline(dq,ctxt,func,dc_flags)
dq->dq_width==1 return _dispatch_barrier_sync_f(dq,ctxt,func,dc_flags)
dispatch_sync_function_invoke_inlie(dq,ctxt,func)
thread_frame dtf
push(&dtf,dq)
client_callout(ctxt,func) //block函数
pop(&dtf)
return _dispatch_lane_barrier_complete(dq)//释放
os_atomic_rww_loop_give_up 护犊子操作
GCD-死锁
dispatch_sync_f_slow
lock_by(lock_value,tid)
return (lock_value ^ tid)&DLOCK_OWNER_MASK == 0 //异或操作 相同=0 不同=1
判断当前队列与正在执行的队列是否相同 返回一个状态值
dq_state_drain_lock_by(dq_state,dispatch_sync_context_t dsc->dsc_waiter)
DISPATCH_CLIENT_CRASH(dq_state){
"dispatch_sync called on queue already owned by current thread"
}
GCD-调度组
搭配使用（实际上就是同步效果）
dispatch_group_async 进组任务
dispatch_group_create{
dg=alloc(group,sizeof(groups))
dg->do_next=LISTLESS
dg->do_target=default_queue
return dg
}
dispatch_group_enter{
old_bits=os_atomic_sub_orig2o(dg,dg_bits,GROUP_VALUE,acquire)
old_value=old_bits&MASK
如果old_value==0 retain(dg)
如果old_value==VALUE_MAX(CRASH"Too many nested calls to dispatch_group_enter")
}
dispatch_group_notify(监听调度组)只保证enter 和 leave 成对存在(dispatch_group_t dg,dq,dsn){
如果old_state==0 os_atomic_rmw_loop_give_up &return dispatch_group_weak苏醒
异步函数push pop invoke 等等
}
dispatch_group_leave差不多的操作{
new_state,old_state = os_atomic_add_orig2o(dg,dg_state,VALUE,release)
os_atomic_rmw_loop_give_up &return dispatch_group_weak苏醒
if old_value==0 ("Unbalanced call to dispatch leave")
}
GCD-信号量
dispatch_semphore_create(n) 控制GCD最大并发数
n=1 同步
n>=2 异步
dispatch_semphore_signal(dispatch_semaphore_t dsema){
os_atomic_inc2o(dsema,dsema_value,release)
add(dsema->dsema_value,1,m,add)
}
if value>0 return
or return signal_slow(dsema)长等待
总而言之：
1.create创建信号量
2.wait等待 os_atomic_des2o(dsema,dsema_value,release){
des(dsema->dsema_value,1,m,des)
if value >=0 return
}
3.释放
dispatch_semaphore_wait_slow(dsema,timeout)
GCD-source
create 创建源
set_event_handler 设置事件回调
merge_data 事件数据
get_data
resume 继续
suspend 挂起
GCD-synchronized
synchronized{
1.objc_sync_enter
2.objc_sync_exit
}
Lv1 源码层:
enter{
SyncData *data=id2data(obj,Acquired)
data->mutex.lock()
}
exit{
OBJC_Sync_success
Bool ok=data->mutex.unlock()
}
Lv2 :
typedef struct alignas(CacheLineSize)SyncData{
struct SyncData* nextData;下一个节点 链表结构
recursive_mutex_t mutex 定义一个递归锁
threadCount //计算有多少个线程正在使用这个block
}
id2Data{
tls->kvc 暂存空间，检查每个线程的单入口类匹配当前对象
bool fastcacheOccupied=No;
SyncData *data=tls_get_direct 拿到Key
if (data){
fastcacheOccupied=Yes
又一岑判断当前对象是否为key所绑定的对象
if data->objcet==object{
lockCount 记录有多少把锁，锁住了这个对象
lockCount=tls_get_direct(SYNC_COUNT_KEY)
switch(Acquired,Release)
tls_set_direct(COUNT_KEY,lockCount)
result->nextData =*listp 如果当前对象数据有下层依赖，切换成下一个节点
*listp = result
lockp.lock
{
SyncData *p
SyncData firstUnused = NULL;
for (p=*listp;p!=NULL;p=p->nextData){
且判断是否有下一个节点，如果没有break，还有继续循环
循环访问p->nextData 访问尾节点
result = p 结果赋值
OSAutomicIncrement32Barrier(&result->threadCount)
调用OS底层(取到线程数量地址)
}
Release check 没有正确的数据关联到这个对象
if firstUnused != NULL{
如果该对象并不是第一次上锁
那么该对象有三种状态
1.第一次没有锁
2.不是第一次，同一个线程加的锁
3.不是第一次，不同进程加的锁
存到tls临时变量里方便缓存cache查找，如果有多个线程锁同一个对象，必定在cache留下痕迹
}
if (!fastcacheOccupied){
tls_set_direct{DATA_KEY,COUNT_KEY}
}
if (!cache){
fetch_cache(YES)
cache->list[cache->used].data=result
cache->list[cache->used].lockCount = 1
cache->used
if(cache){
for i=0;i<cache->used;i {
SyncCacheItem *item = &cache->list[i]
if (item->data->object!=objcet)继续查找{
result=item->data 寻找下一个节点数据
直到在cache找到，证明不是第一次加锁 如果cache判断为真
找到有两种操作 Required / Releas
break
}
}
}
}
}
}
}
}id2Data结束
总结：Synchronized为何性能如此低，且泛用性高，不用忘记解锁
