[iOS]iOS面试题整理

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0 *Desc;
    int age;
}

// 底层结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  Person *__strong person;
};

// 底层block
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  Person *__weak weakPerson;
};

__block：
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_age_0 *age; // by ref
};

struct __Block_byref_age_0 {
  void *__isa; // isa指针
__Block_byref_age_0 *__forwarding; // 如果这block是在堆上那么这个指针就是指向它自己，如果这个block是在栈上，那这个指针是指向它拷贝到堆上后的那个block
 int __flags;
 int __size; // 结构体大小
 int age; // 真正捕获到的age
};

struct SideTable {
    spinlock_t slock;           // 自旋锁，防止多线程访问冲突
    RefcountMap refcnts;        // 对象引用计数map
    weak_table_t weak_table;    // 对象弱引用map
};

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
    struct {
        uintptr_t nonpointer        : 1;
        uintptr_t has_assoc         : 1; //有关联的对象
        uintptr_t has_cxx_dtor      : 1; //c++ 析构
        uintptr_t shiftcls          : 33; // MACH_VM_MAX_ADDRESS 0x1000000000
        uintptr_t magic             : 6; //判断当前对象是真的对象还是没有初始化的空间
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1; //是否有sidetable引用计数
        uintptr_t extra_rc          : 19; //引用计数
#       define RC_ONE   (1ULL<<45)
#       define RC_HALF  (1ULL<<18)
    };

struct SideTable {
    spinlock_t slock;
    RefcountMap refcnts;
    weak_table_t weak_table;
};

struct weak_table_t {
    weak_entry_t *weak_entries;
    size_t    num_entries;
    uintptr_t mask;
    uintptr_t max_hash_displacement;
};

struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    union {
        struct {
            weak_referrer_t *referrers;
            uintptr_t        out_of_line_ness : 2;
            uintptr_t        num_refs : PTR_MINUS_2;
            uintptr_t        mask;
            uintptr_t        max_hash_displacement;
        };
        struct {
            // out_of_line_ness field is low bits of inline_referrers[1]
            weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
        };
    };
    ......
}

id weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, WeakRegisterDeallocatingOptions deallocatingOptions){
.....
        if (deallocating) {
            if (deallocatingOptions == CrashIfDeallocating) {
                _objc_fatal("Cannot form weak reference to instance (%p) of "
                            "class %s. It is possible that this object was "
                            "over-released, or is in the process of deallocation.",
                            (void*)referent, object_getClassName((id)referent));
            } else {
                return nil;
            }
        }
.....
}

inline void
objc_object::rootDealloc()
{
    if (isTaggedPointer()) return;  // fixme necessary?

    if (fastpath(isa.nonpointer  &&   //为1表示优化后的isa即isa_t
                 !isa.weakly_referenced  &&   //无弱引用,不需要释放sidetable
                 !isa.has_assoc  &&   //无关联属性，例如分类中添加的
                 !isa.has_cxx_dtor  &&  //不需要调用c++析构方法
                 !isa.has_sidetable_rc)) //无sidetable引用计数
    {
        assert(!sidetable_present());
        free(this);
    } 
    else {
        object_dispose((id)this); //正常释放
    }
}

/***********************************************************************
* objc_destructInstance
* Destroys an instance without freeing memory. 
* Calls C++ destructors.
* Calls ARC ivar cleanup.
* Removes associative references.
* Returns `obj`. Does nothing if `obj` is nil.
**********************************************************************/
void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = obj->hasAssociatedObjects();

        // This order is important.
        if (cxx) object_cxxDestruct(obj); //c++析构函数调用
        if (assoc) _object_remove_assocations(obj); //关联对象移除 是一个hash表
        obj->clearDeallocating(); //这里进行弱引用表sidetable的相关释放操作，包括表的释放以及引用计数
    }

    return obj;
}

inline void 
objc_object::clearDeallocating()
{
    if (slowpath(!isa.nonpointer)) {
        // Slow path for raw pointer isa.
        sidetable_clearDeallocating();
    }
    else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
        // Slow path for non-pointer isa with weak refs and/or side table data.
        clearDeallocating_slow();
    }

    assert(!sidetable_present());
}

// Slow path of clearDeallocating() 
// for objects with nonpointer isa
// that were ever weakly referenced 
// or whose retain count ever overflowed to the side table.
NEVER_INLINE void
objc_object::clearDeallocating_slow()
{
    assert(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));

    SideTable& table = SideTables()[this];
    table.lock();
    if (isa.weakly_referenced) {
        weak_clear_no_lock(&table.weak_table, (id)this);
    }
    if (isa.has_sidetable_rc) {
        table.refcnts.erase(this);
    }
    table.unlock();
}

#endif

全局AssociationsManager
-----AssociationsHashMap
----------DISGUISE(object):ObjectAssociationMap
--------------------key:ObjcAssociation 对象(存储 policy,value)

typedef struct NCTbl {
  Observation   *wildcard;  /* 保存既没有没有传入通知名字也没有传入object的通知*/
 MapTable       nameless;   /*保存没有传入通知名字的通知 */
 MapTable       named; /*保存传入了通知名字的通知 */
} NCTable;

typedef struct  Obs {
  id        observer;   /* 保存接受消息的对象*/
  SEL       selector;   /* 保存注册通知时传入的SEL*/
  struct Obs    *next;      /* 保存注册了同一个通知的下一个观察者*/
  struct NCTbl  *link;  /* 保存改Observation的Table*/
} Observation;

Named Table
--Key：Table
------Object：单向链表（Observer-Observer-Observer-Observer）

nameless Table
--Object：单向链表（Observer-Observer-Observer-Observer）

NSNotification *notification = [NSNotification notificationWithName:kNotificationName
                                                                     object:@"object"];
[[NSNotificationQueue defaultQueue] enqueueNotification:notification postingStyle:NSPostASAP]

- (void)enqueueNotification:(NSNotification *)notification postingStyle:(NSPostingStyle)postingStyle coalesceMask:(NSNotificationCoalescing)coalesceMask forModes:(nullable NSArray<NSRunLoopMode> *)modes;

typedef NS_ENUM(NSUInteger, NSPostingStyle) {
    NSPostWhenIdle = 1, //runloop空闲时发送
    NSPostASAP = 2,     //当前通知或者timer的回调执行完毕时发送
    NSPostNow = 3       //多个相同的通知合并之后马上发送
};

typedef NS_OPTIONS(NSUInteger, NSNotificationCoalescing) {
    NSNotificationNoCoalescing = 0,         //不管是否重复，不合并
    NSNotificationCoalescingOnName = 1,     //按照通知的名字
    NSNotificationCoalescingOnSender = 2    //按照发送方
};

struct objc_class{
    Class isa  OBJC_ISA_AVAILABILITY;
    #if!__OBJC2__Class super_class                      
    OBJC2_UNAVAILABLE;// 父类constchar*name                        
    OBJC2_UNAVAILABLE;// 类名longversion                            
    OBJC2_UNAVAILABLE;// 类的版本信息，默认为0longinfo                              OBJC2_UNAVAILABLE;// 类信息，供运行期使用的一些位标识longinstance_size                      OBJC2_UNAVAILABLE;// 该类的实例变量大小

    struct objc_ivar_list *ivars OBJC2_UNAVAILABLE;// 该类的成员变量链表
    struct objc_method_list **methodLists OBJC2_UNAVAILABLE;// 方法定义的链表
    struct objc_cache *cacheOBJC2_UNAVAILABLE;// 方法缓存
    struct objc_protocol_list *protocols OBJC2_UNAVAILABLE;// 协议链表#endif
} OBJC2_UNAVAILABLE;

typedef struct category_t {
    const char *name;//类的名字
    classref _tcls;//类
    struct method_list_t *instanceMethods;//category中所有给类添加的实例方法的列表
    struct method_list_t *classMethods;//category中所有添加的类方法的列表
    struct protocol_list_t *protocols;//category实现的所有协议的列表
    struct property_list_t *instanceProperties;//category中添加的所有属性
}category_t;

dealloc
    object_dispose
        objc_destructInstance
            _object_remove_assocations

+ (instancetype )sharedInstance {
    static dispatch_once_t onceToken;
    static SQFlutterLoadChannelManager *_instance;
    dispatch_once(&onceToken, ^{
        if (_instance == nil) {
            _instance = [[SQFlutterLoadChannelManager alloc] init];
        }
    });
    return _instance;
}

// 我们调用dispatch_once的入口
void dispatch_once(dispatch_once_t *val, dispatch_block_t block)
{
    // 内部又调用了dispatch_once_f函数
    dispatch_once_f(val, block, _dispatch_Block_invoke(block));
}

DISPATCH_NOINLINE
void dispatch_once_f(dispatch_once_t *val, void *ctxt, dispatch_function_t func) {
    return dispatch_once_f_slow(val, ctxt, func);
}

DISPATCH_ONCE_SLOW_INLINE
static void
dispatch_once_f_slow(dispatch_once_t *val, void *ctxt, dispatch_function_t func)
{
    // _dispatch_once_waiter_t格式：
    // typedef struct _dispatch_once_waiter_s {
    //      volatile struct _dispatch_once_waiter_s *volatile dow_next;
    //      dispatch_thread_event_s dow_event;
    //      mach_port_t dow_thread;
    // } *_dispatch_once_waiter_t;


    // volatile：告诉编译器不要对此指针进行代码优化，因为这个指针指向的值可能会被其他线程改变
    _dispatch_once_waiter_t volatile *vval = (_dispatch_once_waiter_t*)val;
    struct _dispatch_once_waiter_s dow = { };
    _dispatch_once_waiter_t tail = &dow, next, tmp;
    dispatch_thread_event_t event;

    // 第一次执行时，*vval为0，此时第一个参数vval和第二个参数NULL比较是相等的，返回true，然后把tail赋值给第一个参数的值。如果这时候同时有别的线程也进来，此时vval的值不是0了，所以会来到else分支。
    if (os_atomic_cmpxchg(vval, NULL, tail, acquire)) {
        // 获取当前线程
        dow.dow_thread = _dispatch_tid_self();
        // 调用block函数，一般就是我们在外面做的初始化工作
        _dispatch_client_callout(ctxt, func);

        // 内部将DLOCK_ONCE_DONE赋值给val，将当前标记为已完成，返回之前的引用值。前面说过了，把tail赋值给val了，但这只是没有别的线程进来走到下面else分支，如果有别的线程进来next就是别的值了，如果没有别的信号量在等待，工作就到此结束了。
        next = (_dispatch_once_waiter_t)_dispatch_once_xchg_done(val);
        // 如果没有别的线程进来过处于等待，这里就会结束。如果有，则遍历每一个等待的信号量，然后一个个唤醒它们
        while (next != tail) {
            // 内部用到了thread_switch，避免优先级反转。把next->dow_next返回
            tmp = (_dispatch_once_waiter_t)_dispatch_wait_until(next->dow_next);
            event = &next->dow_event;
            next = tmp;
            // 唤醒信号量
            _dispatch_thread_event_signal(event);
        }
    } else {
        // 内部就是_dispatch_sema4_init函数，也就是初始化一个信号链表
        _dispatch_thread_event_init(&dow.dow_event);
        // next指向新的原子
        next = *vval;
        // 不断循环等待
        for (;;) {
            // 前面说过第一次进来后进入if分支，后面再次进来，会来到这里，但是之前if里面被标志为DISPATCH_ONCE_DONE了，所以结束。
            if (next == DISPATCH_ONCE_DONE) {
                break;
            }
            // 当第一次初始化的时候，同时有别的线程也进来，这是第一个线程已经占据了if分支，但其他线程也是第一进来，所以状态并不是DISPATCH_ONCE_DONE，所以就来到了这里
            // 比较vval和next是否一样，其他线程第一次来这里肯定是相等的
            if (os_atomic_cmpxchgv(vval, next, tail, &next, release)) {
                dow.dow_thread = next->dow_thread;
                dow.dow_next = next;
                if (dow.dow_thread) {
                    pthread_priority_t pp = _dispatch_get_priority();
                    _dispatch_thread_override_start(dow.dow_thread, pp, val);
                }
                // 等待唤醒，唤醒后就做收尾操作
                _dispatch_thread_event_wait(&dow.dow_event);
                if (dow.dow_thread) {

                    _dispatch_thread_override_end(dow.dow_thread, val);
                }
                break;
            }
        }
        // 销毁信号量
        _dispatch_thread_event_destroy(&dow.dow_event);
    }
}

- 当点击屏幕后
- - 事件会传递给UIApplication
- - - - 传递给当前的UIWindow
- - - - - - -UIWindow通过调用- (UIView *)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event方法返回响应视图。
- - - - - - - - - 其中hitTest:withEvent:内部会调用- (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event方法判断点击位置是否在UIWindow范围内，
- - - - - - - - - - - - 如果是的话就会【倒序遍历】（最后添加的视图最先遍历）UIWindow的子视图，从而找出响应视图并返回。

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event { 
    // 1.自己先处理事件...
    NSLog(@"do somthing...");
    // 2.再调用系统的默认做法，再把事件交给上一个响应者处理
    [super touchesBegan:touches withEvent:event]; 
}