浅墨入画
浅墨入画

类加载原理补充-关联对象底层原理

分类加载的补充

objc4-818.2源码中创建LGPerson类以及LGPerson+LGA、LGPerson+LGB分类，其中LGPerson类中未实现+ (void)load{}方法，分类中实现了load方法。源码load_categories_nolock、attachCategories方法中分别添加了如下代码

const char *mangledName = cls->nonlazyMangledName();
if (strcmp(mangledName, "LGPerson") == 0)
{
     printf("%s -LGPerson....\n",__func__);
}
  • 在添加的代码printf("%s -LGPerson....\n",__func__);处添加断点
  • main方法中添加如下代码，运行源码进行调试
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // class_data_bits_t
        LGPerson * person = [LGPerson alloc];
        [person saySomething];
    }
    return 0;
}


(lldb) p ro.baseMethods()
(method_list_t *) $0 = 0x00000001000044e8
  Fix-it applied, fixed expression was: 
    ro->baseMethods()
(lldb) p *$0 
(method_list_t) $1 = {
  entsize_list_tt = (entsizeAndFlags = 27, count = 10)
}
(lldb) p $1.get(0)   // 指针地址指向的就是method_t
(method_t) $2 = {}
  • 由源码可知method_list_t继承自entsize_list_tt，查看其源码
struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;

    uint32_t entsize() const {
        return entsizeAndFlags & ~FlagMask;
    }
    uint32_t flags() const {
        return entsizeAndFlags & FlagMask;
    }

    Element& getOrEnd(uint32_t i) const { 
        ASSERT(i <= count);
        return *PointerModifier::modify(*this, (Element *)((uint8_t *)this + sizeof(*this) + i*entsize()));
    }
    Element& get(uint32_t i) const { 
        ASSERT(i < count);
        // 获取方法实际上调用的getOrEnd
        return getOrEnd(i);
    }

    size_t byteSize() const {
        return byteSize(entsize(), count);
    }
    
    static size_t byteSize(uint32_t entsize, uint32_t count) {
        return sizeof(entsize_list_tt) + count*entsize;
    }
  ......
  • 由上面工程调试可知执行了源码attachCategories方法

如果我们把分类LGPerson+LGA中的load方法屏蔽掉，再运行工程，发现没有执行attachCategories方法，打印信息如下

readClass LGPerson....
_read_images LGPerson....
realizeClassWithoutSwift LGPerson....
prepareMethodLists - LGPerson....
realizeClassWithoutSwift LGPerson....
methodizeClass -LGPerson....
prepareMethodLists - LGPerson....
attachToClass -LGPerson....
getMethodNoSuper_nolock -LGPerson....
2021-08-28 17:27:22.788465+0800 KCObjcBuild[79133:10109465] -[LGPerson(LGB) saySomething]

如果再创建分类LGPerson+LGC、LGPerson+LGD，其中分类LGPerson+LGC实现load方法，运行工程发现执行了attachCategories方法，打印信息如下

readClass LGPerson....
operator() -LGPerson....
operator() -LGPerson....
operator() -LGPerson....
operator() -LGPerson....
realizeClassWithoutSwift LGPerson....
prepareMethodLists - LGPerson....
prepareMethodLists - LGPerson....
realizeClassWithoutSwift LGPerson....
methodizeClass -LGPerson....
prepareMethodLists - LGPerson....
attachToClass -LGPerson....
attachToClass -LGPerson....
attachCategories - LGPerson....
prepareMethodLists - LGPerson....
getMethodNoSuper_nolock -LGPerson....
2021-08-28 17:41:17.662930+0800 KCObjcBuild[79229:10118616] -[LGPerson(LGB) saySomething]

得出结论：

  • 超过一个分类实现了load方法，就会执行attachCategories方法

load_images方法添加断点，重新运行工程进行调试

image.png

主类中没有实现load方法，迫使执行prepare_load_methods方法，继续调试执行到realizeClassWithoutSwift -> attachCategories

image.png

疑问：明明有四个分类，这里为什么之后两个？

// lldb进行调试查看
(lldb) p cats_list[0]
(const locstamped_category_t) $0 = {
  cat = 0x0000000100004438
  hi = 0x0000000100936c90
}
(lldb) p $0.cat 
(category_t *const) $1 = 0x0000000100004438
(lldb) p *$1 
(category_t) $2 = {
  name = 0x0000000100003af6 "LGA"
  cls = 0x0000000100004988
  instanceMethods = {
    ptr = 0x0000000100004388
  }
  classMethods = {
    ptr = 0x00000001000043d8
  }
  protocols = 0x0000000000000000
  instanceProperties = 0x0000000100004410
  _classProperties = 0x0000000000000000
}
(lldb) p cats_list[1]
(const locstamped_category_t) $3 = {
  cat = 0x0000000100004830
  hi = 0x0000000100936c90
}
(lldb) p $3.cat 
(category_t *const) $4 = 0x0000000100004830
(lldb) p *$4
(category_t) $5 = {
  name = 0x0000000100003b07 "LGB"
  cls = 0x0000000100004988
  instanceMethods = {
    ptr = 0x0000000100004768
  }
  classMethods = {
    ptr = 0x00000001000047b8
  }
  protocols = 0x0000000000000000
  instanceProperties = 0x0000000100004808
  _classProperties = 0x0000000000000000
}

通过上面调试发现只有LGA、LGB，因为创建的LGC、LGD没有添加任何属性与方法，所以只有两个

LLVM读取class_ro和分类

分类的加载需要排序。由attachList可知methodList中存储的是LGA的数组指针(排序) 、LGB的数组指针(排序)、主类的数组指针(排序)

  • 查看attachToClass源码，最终执行到attachCategories 
static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
                 int flags)
{
    if (slowpath(PrintReplacedMethods)) {
        printReplacements(cls, cats_list, cats_count);
    }
    if (slowpath(PrintConnecting)) {
        _objc_inform("CLASS: attaching %d categories to%s class '%s'%s",
                     cats_count, (flags & ATTACH_EXISTING) ? " existing" : "",
                     cls->nameForLogging(), (flags & ATTACH_METACLASS) ? " (meta)" : "");
    }

    constexpr uint32_t ATTACH_BUFSIZ = 64;
    method_list_t   *mlists[ATTACH_BUFSIZ];
    property_list_t *proplists[ATTACH_BUFSIZ];
    protocol_list_t *protolists[ATTACH_BUFSIZ];

    uint32_t mcount = 0;
    uint32_t propcount = 0;
    uint32_t protocount = 0;
    bool fromBundle = NO;
    bool isMeta = (flags & ATTACH_METACLASS);
    auto rwe = cls->data()->extAllocIfNeeded();
    
    auto rw = cls->data();
    auto ro = rw->ro();
    const char *mangledName = cls->nonlazyMangledName();
    if (strcmp(mangledName, "LGPerson") == 0)
    {
        if (!isMeta) {
            printf("%s - LGPerson....\n",__func__);
        }
    }

    for (uint32_t i = 0; i < cats_count; i++) {
        // 分类列表cats_list
        auto& entry = cats_list[i];
        // 读取分类中的方法
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            if (mcount == ATTACH_BUFSIZ) {
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__);
                rwe->methods.attachLists(mlists, mcount);
                mcount = 0;
            }
            mlists[ATTACH_BUFSIZ - ++mcount] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist =
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            if (propcount == ATTACH_BUFSIZ) {
                rwe->properties.attachLists(proplists, propcount);
                propcount = 0;
            }
            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta);
        if (protolist) {
            if (protocount == ATTACH_BUFSIZ) {
                rwe->protocols.attachLists(protolists, protocount);
                protocount = 0;
            }
            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
        }
    }

    if (mcount > 0) {
        // 对methodList进行排序
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount,
                           NO, fromBundle, __func__);
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
        if (flags & ATTACH_EXISTING) {
            flushCaches(cls, __func__, [](Class c){
                // constant caches have been dealt with in prepareMethodLists
                // if the class still is constant here, it's fine to keep
                return !c->cache.isConstantOptimizedCache();
            });
        }
    }

    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);
    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
}
  • 主类LGPerson、分类LGA、LGB里面都有saySomething方法，按照之前二分查找逻辑查找saySomething方法，如果没有找到，执行--(减减操作)。疑问？LGA、LGB会--几次？
  1. main函数[person saySomething];处添加断点
  2. 查看lookUpImpOrForward源码
// 慢速查找
// 方法调用 objc_msgSend
// 1 —— 发送消息objc_msgSend 缓存快速查找（cache_t）
// 2 —— 没有命中，lookUpImpOrForward慢速查找
NEVER_INLINE
IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    // 省略代码
 ......
    //    加锁，目的是保证读取的线程安全
    runtimeLock.lock();

    //  是否是已知类：判断当前类是否是已经被认可的类，即已经加载的类
    checkIsKnownClass(cls);

    // 判断类是否实现，如果没有，需要先实现
    cls = realizeAndInitializeIfNeeded_locked(inst, cls, behavior & LOOKUP_INITIALIZE);
    // runtimeLock may have been dropped but is now locked again
    runtimeLock.assertLocked();
    curClass = cls;

    //    递归
    for (unsigned attempts = unreasonableClassCount();;) {
        if (curClass->cache.isConstantOptimizedCache(/* strict */true)) {
#if CONFIG_USE_PREOPT_CACHES
            imp = cache_getImp(curClass, sel);
            if (imp) goto done_unlock;
            curClass = curClass->cache.preoptFallbackClass();
#endif
        } else {
            // curClass method list.
            // 在当前的类的方法列表中查找方法（采用二分查找算法），如果找到，则返回，将方法缓存到cache中
            Method meth = getMethodNoSuper_nolock(curClass, sel);
            if (meth) {
                imp = meth->imp(false);
                goto done;
            }

            // 未找到，superclass找到父类或者父元类继续查找，如果父类是nil，默认赋值forward_imp
            if (slowpath((curClass = curClass->getSuperclass()) == nil)) {
                // No implementation found, and method resolver didn't help.
                // Use forwarding.
                // 父类为nil，即继承链都未找到方法实现，跳出循环
                imp = forward_imp;
                break;
            }
        }

        // Halt if there is a cycle in the superclass chain.
        if (slowpath(--attempts == 0)) {
            _objc_fatal("Memory corruption in class list.");
        }

        // Superclass找到父类，在父类的cache中查找.
        // 从父类缓存中查找 - 再次进入汇变查找
        // - 如果查找到done
        // - 查找不到，循环superclass，再查找父类
        // Superclass cache.
        imp = cache_getImp(curClass, sel);
        if (slowpath(imp == forward_imp)) {
            break;
        }
        if (fastpath(imp)) {
            // Found the method in a superclass. Cache it in this class.
            goto done;
        }
    }
...... //省略代码
}
  1. 查看getMethodNoSuper_nolock源码，在printf("%s -LGPerson....\n",__func__);添加断点
  2. 运行工程，断点执行到printf("%s -LGPerson....\n",__func__);，执行调试
image.png 
// lldb调试信息
(lldb) p methods.beginLists()
(const method_list_t_authed_ptr *) $0 = 0x00007ffeefbfeea0
(lldb) p *$0 
(const method_list_t_authed_ptr) $1 = {
  ptr = 0x00000001000041c8
}
(lldb) p $1.ptr 
(method_list_t *const) $2 = 0x00000001000041c8
(lldb) p *$2 
(method_list_t) $3 = {
  entsize_list_tt = (entsizeAndFlags = 27, count = 16)
}
  1. 查看search_method_list_inline方法源码 -> findMethodInUnsortedMethodList方法源码
ALWAYS_INLINE static method_t *
findMethodInUnsortedMethodList(SEL key, const method_list_t *list)
{
    if (list->isSmallList()) {
        if (CONFIG_SHARED_CACHE_RELATIVE_DIRECT_SELECTORS && objc::inSharedCache((uintptr_t)list)) {
            // 二分查找
            return findMethodInUnsortedMethodList(key, list, [](method_t &m) { return m.getSmallNameAsSEL(); });
        } else {
            return findMethodInUnsortedMethodList(key, list, [](method_t &m) { return m.getSmallNameAsSELRef(); });
        }
    } else {
        return findMethodInUnsortedMethodList(key, list, [](method_t &m) { return m.big().name; });
    }
}

/***********************************************************************
 * search_method_list_inline
 **********************************************************************/
template
ALWAYS_INLINE static method_t *
findMethodInSortedMethodList(SEL key, const method_list_t *list, const getNameFunc &getName)
{
    ASSERT(list);

    auto first = list->begin();
    auto base = first;
    decltype(first) probe;

    uintptr_t keyValue = (uintptr_t)key;
    uint32_t count;
    // base相当于low地址，count是max地址，probe是middle地址
    for (count = list->count; count != 0; count >>= 1) {
        // 指针平移至中间位置
        // 从首地址 + 下标 --> 移动到中间位置（count >> 1）
        probe = base + (count >> 1);
        // 获取该位置的sel名称
        uintptr_t probeValue = (uintptr_t)getName(probe);
        // 如果查找的key的keyvalue等于中间位置（probe）的probeValue，则直接返回中间位置
        if (keyValue == probeValue) {
            // `probe` is a match.
            // Rewind looking for the *first* occurrence of this value.
            // This is required for correct category overrides.
            // 分类方法同名- while 平移 -- 向前在查找，判断是否存在相同的方法，保证调用的是分类的
            while (probe > first && keyValue == (uintptr_t)getName((probe - 1))) {
                probe--;
            }
            return &*probe;
        }
        // 如果keyValue 大于 probeValue，就往probe即中间位置的右边查找，即中间位置再右移
        if (keyValue > probeValue) {
            base = probe + 1;
            count--;
        }
    }
    
    return nil;
}
  1. 上面代码while (probe > first && keyValue == (uintptr_t)getName((probe - 1))) { probe--; }为什么要执行probe--？
    原因是本类方法、分类方法都整合在一块了，这里一定找的是最前面(最先加载)的分类方法saySomething。

class_ro_t的数据结构是怎么通过一个指针得到的？

  • 打开llvm查看class_ro_t源码 
  struct class_ro_t {
    uint32_t m_flags;
    uint32_t m_instanceStart;
    uint32_t m_instanceSize;
    uint32_t m_reserved;

    lldb::addr_t m_ivarLayout_ptr;
    lldb::addr_t m_name_ptr;
    lldb::addr_t m_baseMethods_ptr;
    lldb::addr_t m_baseProtocols_ptr;
    lldb::addr_t m_ivars_ptr;

    lldb::addr_t m_weakIvarLayout_ptr;
    lldb::addr_t m_baseProperties_ptr;

    std::string m_name;

    bool Read(Process *process, lldb::addr_t addr);
  };

// 读取当前address
bool ClassDescriptorV2::class_ro_t::Read(Process *process, lldb::addr_t addr) {
  size_t ptr_size = process->GetAddressByteSize();

  size_t size = sizeof(uint32_t)   // uint32_t flags;
                + sizeof(uint32_t) // uint32_t instanceStart;
                + sizeof(uint32_t) // uint32_t instanceSize;
                + (ptr_size == 8 ? sizeof(uint32_t)
                                 : 0) // uint32_t reserved; // __LP64__ only
                + ptr_size            // const uint8_t *ivarLayout;
                + ptr_size            // const char *name;
                + ptr_size            // const method_list_t *baseMethods;
                + ptr_size            // const protocol_list_t *baseProtocols;
                + ptr_size            // const ivar_list_t *ivars;
                + ptr_size            // const uint8_t *weakIvarLayout;
                + ptr_size;           // const property_list_t *baseProperties;

  DataBufferHeap buffer(size, '\0');
  Status error;

  process->ReadMemory(addr, buffer.GetBytes(), size, error);
  if (error.Fail()) {
    return false;
  }

  DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
                          process->GetAddressByteSize());

  lldb::offset_t cursor = 0;
  // 对class_ro_t中相应的成员变量进行赋值
  m_flags = extractor.GetU32_unchecked(&cursor);
  m_instanceStart = extractor.GetU32_unchecked(&cursor);
  m_instanceSize = extractor.GetU32_unchecked(&cursor);
  if (ptr_size == 8)
    m_reserved = extractor.GetU32_unchecked(&cursor);
  else
    m_reserved = 0;
  m_ivarLayout_ptr = extractor.GetAddress_unchecked(&cursor);
  m_name_ptr = extractor.GetAddress_unchecked(&cursor);
  m_baseMethods_ptr = extractor.GetAddress_unchecked(&cursor);
  m_baseProtocols_ptr = extractor.GetAddress_unchecked(&cursor);
  m_ivars_ptr = extractor.GetAddress_unchecked(&cursor);
  m_weakIvarLayout_ptr = extractor.GetAddress_unchecked(&cursor);
  m_baseProperties_ptr = extractor.GetAddress_unchecked(&cursor);

  DataBufferHeap name_buf(1024, '\0');

  process->ReadCStringFromMemory(m_name_ptr, (char *)name_buf.GetBytes(),
                                 name_buf.GetByteSize(), error);

  if (error.Fail()) {
    return false;
  }

  m_name.assign((char *)name_buf.GetBytes());

  return true;
}
  • 在llvm中寻找哪里调用了Read方法？最终查找到在Read_class_row方法中调用
bool ClassDescriptorV2::Read_class_row(
    Process *process, const objc_class_t &objc_class,
    std::unique_ptr &class_ro,
    std::unique_ptr &class_rw) const {
  class_ro.reset();
  class_rw.reset();

  Status error;
  uint32_t class_row_t_flags = process->ReadUnsignedIntegerFromMemory(
      objc_class.m_data_ptr, sizeof(uint32_t), 0, error);
  if (!error.Success())
    return false;

  if (class_row_t_flags & RW_REALIZED) {
    class_rw = std::make_unique();

    if (!class_rw->Read(process, objc_class.m_data_ptr)) {
      class_rw.reset();
      return false;
    }

    class_ro = std::make_unique();

    if (!class_ro->Read(process, class_rw->m_ro_ptr)) {
      class_rw.reset();
      class_ro.reset();
      return false;
    }
  } else {
    class_ro = std::make_unique();

    if (!class_ro->Read(process, objc_class.m_data_ptr)) {
      class_ro.reset();
      return false;
    }
  }
  return true;
}

类扩展分析

面试题：类扩展与分类的区别
1、category 类别、分类

  • 专门用来给类添加新的方法
  • 不能给类添加成员属性，添加了成员属性，也无法取到
  • 注意：其实可以通过runtime 给分类添加属性，即属性关联，重写setter、getter方法
  • 分类中用@property定义变量，只会生成变量的setter、getter方法的声明，不能生成方法实现和带下划线的成员变量

2、extension 类扩展

  • 可以说成是特殊的分类 ，也可称作匿名分类
  • 可以给类添加成员属性，但是是私有变量
  • 可以给类添加方法，也是私有方法

类的扩展有两种创建方式

  • 直接在类中书写：永远在声明之后，在实现之前（需要在.m文件中书写）
  • 通过 command+N 新建 -> Objective-C File -> 选择Extension

下面写一个类扩展

@interface LGStudent : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
- (void)instanceMethod;
+ (void)classMethod;
@end


@interface LGStudent ()
@property (nonatomic, copy) NSString *ext_name;
@property (nonatomic, assign) int ext_age;
- (void)ext_instanceMethod;
+ (void)ext_classMethod;
@end
  • 通过clang -rewrite-objc main.mm -o main.cpp命令生成cpp文件，打开cpp文件，搜索ext_name属性
struct LGStudent_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    int _age;
    int _ext_age;
    NSString *_name;
    NSString *_ext_name;
};
  • 查看成员变量列表_ivar_list_t，发现有两个成员变量_name和_ext_name 
static struct /*_ivar_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count;
    struct _ivar_t ivar_list[4];
} _OBJC_$_INSTANCE_VARIABLES_LGStudent __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_ivar_t),
    4,
    {{(unsigned long int *)&OBJC_IVAR_$_LGStudent$_age, "_age", "i", 2, 4},
     {(unsigned long int *)&OBJC_IVAR_$_LGStudent$_ext_age, "_ext_age", "i", 2, 4},
     {(unsigned long int *)&OBJC_IVAR_$_LGStudent$_name, "_name", "@\"NSString\"", 3, 8},
     {(unsigned long int *)&OBJC_IVAR_$_LGStudent$_ext_name, "_ext_name", "@\"NSString\"", 3, 8}}
};
  • 查看对象方法列表 
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[18];
} _OBJC_$_INSTANCE_METHODS_LGStudent __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    18,
    {{(struct objc_selector *)"instanceMethod", "v16@0:8", (void *)_I_LGStudent_instanceMethod},
    {(struct objc_selector *)"ext_instanceMethod", "v16@0:8", (void *)_I_LGStudent_ext_instanceMethod},
    {(struct objc_selector *)"name", "@16@0:8", (void *)_I_LGStudent_name},
    {(struct objc_selector *)"setName:", "v24@0:8@16", (void *)_I_LGStudent_setName_},
    {(struct objc_selector *)"age", "i16@0:8", (void *)_I_LGStudent_age},
    {(struct objc_selector *)"setAge:", "v20@0:8i16", (void *)_I_LGStudent_setAge_},
    {(struct objc_selector *)"ext_name", "@16@0:8", (void *)_I_LGStudent_ext_name},
    {(struct objc_selector *)"setExt_name:", "v24@0:8@16", (void *)_I_LGStudent_setExt_name_},
    {(struct objc_selector *)"ext_age", "i16@0:8", (void *)_I_LGStudent_ext_age},
    {(struct objc_selector *)"setExt_age:", "v20@0:8i16", (void *)_I_LGStudent_setExt_age_},
    {(struct objc_selector *)"name", "@16@0:8", (void *)_I_LGStudent_name},
    {(struct objc_selector *)"setName:", "v24@0:8@16", (void *)_I_LGStudent_setName_},
    {(struct objc_selector *)"age", "i16@0:8", (void *)_I_LGStudent_age},
    {(struct objc_selector *)"setAge:", "v20@0:8i16", (void *)_I_LGStudent_setAge_},
    {(struct objc_selector *)"ext_name", "@16@0:8", (void *)_I_LGStudent_ext_name},
    {(struct objc_selector *)"setExt_name:", "v24@0:8@16", (void *)_I_LGStudent_setExt_name_},
    {(struct objc_selector *)"ext_age", "i16@0:8", (void *)_I_LGStudent_ext_age},
    {(struct objc_selector *)"setExt_age:", "v20@0:8i16", (void *)_I_LGStudent_setExt_age_}}
};

查看 LGTeacher 类拓展的方法，在编译过程中，方法就直接添加到了methodlist中，作为类的一部分，即编译时期直接添加到本类里面

通过源码调试探索

  • 创建LGPerson+LG.h即类的扩展，并声明两个方法
@interface LGPerson ()
- (void)ext_instanceMethod;
+ (void)ext_classMethod;
@end
  • 在LGPeron.m中实现这两个方法
- (void)ext_instanceMethod{
    NSLog(@"%s",__func__);
}

+ (void)ext_classMethod{
    NSLog(@"%s",__func__);
}
  • 运行objc源码程序，在realizeClassWithoutSwift中断住
image.png 
(lldb) p ro.baseMethods()
(method_list_t *) $0 = 0x00000001000046f0
  Fix-it applied, fixed expression was: 
    ro->baseMethods()
(lldb) p *$0 
(method_list_t) $1 = {
  entsize_list_tt = (entsizeAndFlags = 24, count = 11)
}
(lldb) p $1.get(0).big()
(method_t::big) $2 = {
  name = "saySomething"
  types = 0x0000000100003c65 "v16@0:8"
  imp = 0x0000000100003870 (KCObjcBuild`-[LGPerson saySomething])
}
(lldb) p $1.get(1).big()
(method_t::big) $3 = {
  name = "sayHello1"
  types = 0x0000000100003c65 "v16@0:8"
  imp = 0x00000001000038a0 (KCObjcBuild`-[LGPerson sayHello1])
}
(lldb) p $1.get(2).big()
(method_t::big) $4 = {
  name = "ext_instanceMethod"
  types = 0x0000000100003c65 "v16@0:8"
  imp = 0x00000001000038d0 (KCObjcBuild`-[LGPerson ext_instanceMethod])
}

得出结论：

  • 类的扩展在编译时会作为类的一部分，和类一起编译进来
  • 类的扩展只是声明，依赖于当前的主类，没有.m文件，可以理解为一个·h文件

关联对象初探

关联对象的底层原理的实现，主要分为三部分：

  • 通过objc_setAssociatedObject设值流程
  • 通过objc_getAssociatedObject取值流程
  • 通过objc_removeAssociatedObjects移除关联对象
// 取值流程
id
objc_getAssociatedObject(id object, const void *key)
{
    return _object_get_associative_reference(object, key);
}

// 设值流程
void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    _object_set_associative_reference(object, key, value, policy);
}

// 移除关联对象
void objc_removeAssociatedObjects(id object) 
{
    if (object && object->hasAssociatedObjects()) {
        _object_remove_assocations(object, /*deallocating*/false);
    }
}
关联对象

关联对象底层分析

关联对象-设值流程
  • 在分类LGA中重写属性cate_name的set、get方法，通过runtime的属性关联方法实现
// 分类添加cate_name、cate_age属性
@interface LGPerson (LGA)
@property (nonatomic, copy) NSString *cate_name;
@property (nonatomic, copy) NSString *cate_age;

- (void)saySomething;
- (void)cateA_instanceMethod1;
- (void)cateA_instanceMethod2;
+ (void)cateA_classMethod1;
+ (void)cateA_classMethod2;
@end

// LGPerson+LGA.m文件
- (void)setCate_name:(NSString *)cate_name{
    /**
     1: 对象 2: 标识符 3: value 4: 策略
     */
    objc_setAssociatedObject(self, "cate_name", cate_name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

- (NSString *)cate_name{
    return  objc_getAssociatedObject(self, "cate_name");
}

- (void)setCate_age:(NSString *)cate_age{
    objc_setAssociatedObject(self, "cate_age", cate_age, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

- (NSString *)cate_age{
    return objc_getAssociatedObject(self, "cate_age");
}
  • 运行程序，断点断在main中person.cate_name = @"KC";赋值处
image.png
  • 进入_object_set_associative_reference源码实现，关于关联对象底层原理的探索主要是看value存到了哪里， 以及如何取出value ，以下是源码
// 重磅提示  重点
/**
 关联对象 : 存储 object - cate_name -> value - policy
 */
void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    // This code used to work when nil was passed for object and key. Some code
    // probably relies on that to not crash. Check and handle it explicitly.
    // rdar://problem/44094390
    if (!object && !value) return;

    if (object->getIsa()->forbidsAssociatedObjects())
        _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
    //object封装成一个数组结构类型，类型为DisguisedPtr
    DisguisedPtr disguised{(objc_object *)object};//相当于包装了一下 对象object,便于使用
    // 包装一下 policy - value
    ObjcAssociation association{policy, value};

    // retain the new value (if any) outside the lock.
    association.acquireValue();

    bool isFirstAssociation = false;
    {
        // 初始化manager变量，相当于自动调用AssociationsManager的析构函数进行初始化
        AssociationsManager manager;//并不是全场唯一，构造函数中加锁只是为了避免重复创建，在这里是可以初始化多个AssociationsManager变量的
        AssociationsHashMap &associations(manager.get());//AssociationsHashMap 全场唯一

        if (value) {
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});//返回的结果是一个类对
            if (refs_result.second) {//判断第二个存不存在，即bool值是否为true
                /* it's the first association we make  第一次建立关联*/
                isFirstAssociation = true;//标记位true
            }

            /* establish or replace the association  建立或者替换关联*/
            auto &refs = refs_result.first->second;//得到一个空的桶子，找到引用对象类型,即第一个元素的second值
            auto result = refs.try_emplace(key, std::move(association));//查找当前的key是否有association关联对象
            if (!result.second) {//如果结果不存在
                association.swap(result.first->second);
            }
        } else {//如果传的是空值，则移除关联，相当于移除
            auto refs_it = associations.find(disguised);
            if (refs_it != associations.end()) {
                auto &refs = refs_it->second;
                auto it = refs.find(key);
                if (it != refs.end()) {
                    association.swap(it->second);
                    refs.erase(it);
                    if (refs.size() == 0) {
                        associations.erase(refs_it);

                    }
                }
            }
        }
    }

    if (isFirstAssociation)
        object->setHasAssociatedObjects();

    // release the old value (outside of the lock).
    association.releaseHeldValue();//释放
}
  • 在_object_set_associative_reference源码中添加断点进行调试
image.png 
// lldb调试信息
(lldb) p disguised
(DisguisedPtr) $0 = (value = 18446744069394321632)
(lldb) p association
(objc::ObjcAssociation) $1 = {
  _policy = 3
  _value = 0x0000000100004080 "KC"
}
  • 注意AssociationsManager manager;是个析构函数，并不是单例。
// main.m文件添加如下结构体，进行验证是析构函数
struct LGObjc {
    LGObjc()   { printf("KC 来了 \n");}  //构造函数
    ~LGObjc()  {  printf("大师班 NB \n"); } //析构函数
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        LGObjc kc;
    }
    return 0;
}

// 运行工程打印如下
KC 来了 
大师班 NB
  • 查看AssociationsManager源码，定义AssociationsManager类型的变量，相当于自动调用AssociationsManager的析构函数进行初始化。加锁lock，并不代表 唯一，只是为了避免多线程重复创建，其实在外面是可以定义多个AssociationsManager manager;的
class AssociationsManager {
    using Storage = ExplicitInitDenseMap, ObjectAssociationMap>;
    static Storage _mapStorage; //静态变量

public://构造加锁的原因是 -- 避免多线程重复创建
    AssociationsManager()   { AssociationsManagerLock.lock(); } //构造函数，自动调用
    ~AssociationsManager()  { AssociationsManagerLock.unlock(); }//析构函数，自动调用

    AssociationsHashMap &get() {
        return _mapStorage.get();//从静态变量中获取出来，所以全场唯一
    }

    static void init() {
        _mapStorage.init();
    }
};

  • 定义AssociationsHashMap类型的哈希map是全场唯一的，从哪里可以体现呢？
    通过_mapStorage.get()生成哈希map，其中_mapStorage是一个静态变量，所以哈希map永远是通过静态变量获取出来的，是全场唯一的。AssociationsHashMap哈希表是一个单例

  • 继续上面lldb调试

image.png 
(lldb) p associations
(objc::AssociationsHashMap) $0 = {
  Buckets = 0x0000000000000000
  NumEntries = 0
  NumTombstones = 0
  NumBuckets = 0
}
  • associations调用try_emplace方法，传入一个对象disguised和 一个空的关联mapObjectAssociationMap{} 
(lldb) p refs_result
(std::pair, objc::DenseMap, objc::DenseMapInfo, objc::detail::DenseMapPair >, objc::DenseMapValueInfo, objc::DenseMapInfo, objc::detail::DenseMapPair > >, objc::DenseMapInfo >, objc::detail::DenseMapPair, objc::DenseMap, objc::DenseMapInfo, objc::detail::DenseMapPair > >, false>, bool>) $1 = {
  first = {
    Ptr = 0x0000000100828a20
    End = 0x0000000100828aa0
  }
  second = true
}
  • 查看try_emplace方法的源码实现
  // it is not moved. 如果key不在map中，则直接构造，否则它不会移动
  template 
  std::pair try_emplace(const KeyT &Key, Ts &&... Args) {
    BucketT *TheBucket;
    if (LookupBucketFor(Key, TheBucket))//LookupBucketFor找桶子，其中key是关联对象
      return std::make_pair(//如果桶子存在则返回，置为false的原因是哈希map中已经存在
               makeIterator(TheBucket, getBucketsEnd(), true),
               false); // Already in map. 已经存在直接返回false

    // Otherwise, insert the new element. 第一次来则插入 -- true
    TheBucket = InsertIntoBucket(TheBucket, Key, std::forward(Args)...); //往桶里添加值
    return std::make_pair(
             makeIterator(TheBucket, getBucketsEnd(), true),
             true);//bool值置为true，表示第一次往哈希map中添加桶子
  }
  • 查看LookupBucketFor源码，有两个同名方法，其中第二个方法属于重载函数，区别于第一个的是第二个参数没有const修饰，通过调试可知，外部的调用是调用的第二个重载函数，而第二个LookupBucketFor方法内部的实现是调用第一个LookupBucketFor方法
image.png
  • 断点运行至try_emplace方法中的获取bucket部分TheBucket = InsertIntoBucket(TheBucket, Key, std::forward(Args)...);
image.png 
(lldb) p TheBucket
(objc::detail::DenseMapPair *) $2 = 0x0000000000000000
  • 进入查看InsertIntoBucket源码
template 
  BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
                                BucketT *TheBucket) {
    // If the load of the hash table is more than 3/4, or if fewer than 1/8 of
    // the buckets are empty (meaning that many are filled with tombstones),
    // grow the table.
    //
    // The later case is tricky.  For example, if we had one empty bucket with
    // tons of tombstones, failing lookups (e.g. for insertion) would have to
    // probe almost the entire table until it found the empty bucket.  If the
    // table completely filled with tombstones, no lookup would ever succeed,
    // causing infinite loops in lookup.
    unsigned NewNumEntries = getNumEntries() + 1;
    unsigned NumBuckets = getNumBuckets();
    // 3/4扩容
    if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
      this->grow(NumBuckets * 2);
      LookupBucketFor(Lookup, TheBucket);
      NumBuckets = getNumBuckets();
    } else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
                             NumBuckets/8)) {
      this->grow(NumBuckets);
      LookupBucketFor(Lookup, TheBucket);
    }
    ASSERT(TheBucket);
......//省略代码
  • 调试断点回到_object_set_associative_reference方法
image.png 
(lldb) p refs
(objc::DenseMap, objc::DenseMapInfo, objc::detail::DenseMapPair >) $3 = {
  Buckets = 0x0000000100706680
  NumEntries = 1
  NumTombstones = 0
  NumBuckets = 4
}
(lldb) p result
(std::pair, objc::DenseMapInfo, objc::detail::DenseMapPair, false>, bool>) $4 = {
  first = {
    Ptr = 0x00000001007066b0
    End = 0x00000001007066e0
  }
  second = true
}
(lldb) p $4.first 
(objc::DenseMapIterator, objc::DenseMapInfo, objc::detail::DenseMapPair, false>) $5 = {
  Ptr = 0x00000001007066b0
  End = 0x00000001007066e0
}
// 这就是存进去的bucket
(lldb) p $5.Ptr 
(objc::DenseMapIterator, objc::DenseMapInfo, objc::detail::DenseMapPair, false>::pointer) $6 = 0x00000001007066b0

最终探索到bucket是通过InsertIntoBucket方法的这一段代码TheBucket->getFirst() = std::forward(Key); ::new (&TheBucket->getSecond()) ValueT(std::forward(Values)...);插进去的。

第一次执行try_emplace插入的是一个空桶还没有值，第二次执行try_emplace才插入值，即往空桶中插入ObjectAssociationMap（value，policy），返回true
所以关联对象的设值图示如下，有点类似于cache_t中的insert方法插入sel-imp的逻辑

关联对象设值
关联对象: 设值流程
  • 创建一个AssociationsManager管理类
  • 获取唯一的全局静态哈希Map
  • 判断是否插入的关联值是否存在:
    1: 存在走第4步
    2: 不存在就走 : 关联对象插入空流程
  • 创建一个空的ObjectAssociationMap去取查询的键值对
  • 如果发现没有这个 key 就插入一个 空的BucketT进去返回
  • 标记对象存在关联对象
  • 用当前 修饰策略 和 值 组成了一个ObjcAssociation 替换原来 BucketT 中的空
  • 标记一下 ObjectAssociationMap 的第一次为 false
关联对象插入空流程
  • 根据DisguisedPtr找到 AssociationsHashMap 中的 iterator 迭代查询器
  • 清理迭代器
  • 其实如果插入空值 相当于清除
关联对象的取值流程自己探索，这里简单讲述下取值流程
关联对象: 取值流程
  • 创建一个 AssociationsManager 管理类
  • 获取唯一的全局静态哈希Map
  • 根据 DisguisedPtr 找到 AssociationsHashMap中的 iterator 迭代查询器
  • 如果这个迭代查询器不是最后一个 获取 : ObjectAssociationMap (这里有策略和value)
  • 找到ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
  • 返回_value
    总结: 其实就是两层哈希map , 存取的时候两层处理(类似二位数组)

你可能感兴趣的:(类加载原理补充-关联对象底层原理)

  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • git - Webhook让部署自动化 大猪大猪
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • 2022-11-17 无奇君
    又去了一次社康，这次是急性支气管炎……太难了。半夜就猛咳，天天咳醒，还好他戴海绵耳塞睡吵不到他，要不然对他来说也是种煎熬。一累也会猛咳，希望这次是最后一次吃药，吃完就好。又想把头发剪短了，顺便染个色。可是刚刚去看人家还没开门，不是休息日老板好佛系。理发店是个夫妻店，一年多前刚搬来的时候老板还没对象呢，当时聊天老板就说希望能找个对象一起两个人守着店都比上班强。不久后再去他已经有对象了，而且在店里帮忙
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 【讲解】怎么消除妊娠纹 poyan7160
    女人是脆弱的，尤其是孕期的女性。辛辛苦苦怀胎十月，经历一次深到骨子里的痛还不够，无奈还要留下一身的妊娠纹。母亲是伟大的，但也是要付出代价的，妊娠纹就是最好的证明。可是，难道真的要带着妊娠纹过一辈子吗?不，坚决不!接下来新时代辣妈告诉你怎么去除妊娠纹?怎么去除妊娠纹——根据肌肤需要补充水分就像敷面膜那样，大家都知道敷面膜的目的是为了给肌肤补充水分。水分对一个人的肌肤很重要，只有有了足够的水分，肌肤才
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • 和自己结婚，是一种怎样的体验 只如初见_2020
    一个17岁谈恋爱，19岁结婚，然后离了三次婚的女人，站在台上说：“现在我结婚了，和那个一直以来，真正想在一起的人结婚了，那个人就是我自己。”她说，在我9岁前，我已经在二十几个寄养家庭中待过。我从童年到成年，就只有一个目标，不要被落下。而我实现这一目标的方式就是，我要结婚。我第一次的结婚对象，是我17岁时遇到的人。我们两年之后结了婚，当时我19岁。他是个非常好的人，来自于非常棒的家庭，他是工商管理硕
  • k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
    ?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • 2022-08-28 蔚蓝一片晴
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
  • STM32中的计时与延时 lupinjia STM32stm32单片机
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
  • 在一起的日子 少些期待
    在一起已经三年多了，我是一个97年的摩羯座女生，他是一个89年的同样的摩羯座男生，刚开始是他追的我，我开始对他也挺有好感的，他从他朋友哪里，要到我的电话号，给我发信息，我没理他。然后我们的故事就这样开始了·····我不记得到底是什么，让我对他特别喜欢，想一心一意跟着他过日子，说白了我也就是个他的小跟班，又或者是个小跟屁虫，或者是个保姆，反正就是他在那里，我就得陪他到哪里，谈了半年多对象的时候，他因
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 二婚到底是领证好还是不领证好？ 孟妃青
    伟人讲过，不以结婚为目的的谈恋爱，都是耍流氓！离婚了，再找对象，感情到了一定程度，领证结婚是水到渠成的事，再说我中华泱泱大国，有礼仪之邦的称谓，领证更是体现了尊重男女双方的行为。如果认为二婚就没必要领证了，只能说明，男女之间都暗藏心思，心不往一处走，日子过不好的。即便他们感情再深，都不是合法夫妻，只是名不正言不顺的同居关系。假如不要二人共同的孩子还好，就怕有了孩子，没领证，到时给孩子上户口都成问题
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • python多线程程序设计 之一 IT_Beijing_BIT #Python程序设计语言python
    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • 系统架构设计师 需求分析篇二 AmHardy 软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他