当前位置：网站首页>To get to the bottom: Principle Analysis of Objective-C correlation attribute

To get to the bottom: Principle Analysis of Objective-C correlation attribute

2022-07-19 10:59:00 【51CTO】

get to the bottom of the matter ：Objective-C Principle analysis of correlation attribute

One . Introduction

Objective-C It is a dynamic language , So called dynamic capability , It can also be understood as runtime capability . about Objective-C For developers , The programming convenience brought by dynamics is everywhere . For example, through Category Class to extend the functions of existing classes . You can make existing classes have new methods and properties . however , If you use Category To extend the properties of the class , You must know that it is not easy to use @property Just make a statement . For example, the following code ：

#import <Foundation/Foundation.h>
@interface MyObject : NSObject

@end

@implementation MyObject

@end


@interface MyObject (Property)

@property (nonatomic, copy) NSString *addProperty;

@end

@implementation MyObject (Property)

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        MyObject *object = [[MyObject alloc] init];
        object.addProperty = @"HelloWorld";
        NSLog(@"%@", object.addProperty);
    }
    return 0;
}


     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.
      27.
      28.
      29.

The code will not have any problems at compile time , But if you run , There will be undefined method exceptions . So if you want to extend the properties of a class , We usually do this ：

#import <objc/runtime.h>

@implementation MyObject (Property)

static NSString *kAddPropertyKey = @"kAddPropertyKey";

- (void)setAddProperty:(NSString *)addProperty {
    objc_setAssociatedObject(self, kAddPropertyKey, addProperty, OBJC_ASSOCIATION_COPY);
}

- (NSString *)addProperty {
    return objc_getAssociatedObject(self, kAddPropertyKey);
}

@end

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.

Run again , Can be normal to addProperty Property to access the value . In fact, it is used here Objective-C Runtime features , stay Objective-C in , The memory space occupied by class objects has been determined when they are created , So have you ever thought about , adopt objc_setAssociatedObject How the attribute values stored by this runtime method are associated with the current object , Where do these data exist ？ When lucky , from objc The source code can clearly understand the implementation logic of association attributes , This is also the focus of our article , Understanding the principles here may not help you much in using association properties , But this design idea will definitely benefit you a lot in daily development .

Two . objc_setAssociatedObject The core principle of the method

adopt objc Of runtime Source code , We can see objc_setAssociatedObject The method is as follows ：

void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    _object_set_associative_reference(object, key, value, policy);
}


     
      1.
      2.
      3.
      4.
      5.
      6.

There is no need to explain this step too much , Just called an internal function ,_object_set_associative_reference Internal functions are the core of the implementation of correlation attributes , This function resolves as follows ：

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    // 1. Safety inspection , The object to be associated and the value to be associated cannot be empty 
    if (!object && !value) return;

    // 2. Check whether the current object does not allow associated attributes , Some classes do not allow their instances to have associated properties 
    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));
    
    // 3. Create a structure object that wraps the object pointer , Store the object pointer to associate 
    DisguisedPtr<objc_object> disguised{(objc_object *)object};
    // 4. Create an object that wraps the Association policy and the associated value 
    ObjcAssociation association{policy, value};

    // 5. Reference the value according to the Association policy （retain or copy）
    association.acquireValue();

    bool isFirstAssociation = false;
    {
        // 6. Get the association manager and its association table object 
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());

        // 7. If the value exists , Then we can make a correlation 
        if (value) {
            // 8. Try to insert the object and value currently to be associated into the table , If it already exists , Then do nothing 
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            // 9.  Check try_emplace Insert result of method , If you insert , Then the first association of the mark is true
            if (refs_result.second) {
                isFirstAssociation = true;
            }

            // 10. Compare the values stored in the table with key Association 
            auto &refs = refs_result.first->second;
            auto result = refs.try_emplace(key, std::move(association));
            // 11. If key Already exist , Then exchange the association strategy and association value 
            if (!result.second) {
                association.swap(result.first->second);
            }
        // 12.  The value to associate is nil, Is a clear operation 
        } else {
            // 13.  Find the attribute pair associated with this object 
            auto refs_it = associations.find(disguised);
            if (refs_it != associations.end()) {
                // 14. Associated properties , Get storage key Table of 
                auto &refs = refs_it->second;
                // 15. Find corresponding key Whether there is 
                auto it = refs.find(key);
                if (it != refs.end()) {
                    // 16. Replace the associated data if it exists , Including correlation policies and values , At this time, the value is actually cleared 
                    association.swap(it->second);
                    // 17. Related erase operations 
                    refs.erase(it);
                    if (refs.size() == 0) {
                        associations.erase(refs_it);
                    }
                }
            }
        }
    }

    // 18. Determine whether it is the first association of this kind of instance object , If it is , Then modify the marker bit , Indicates that there are already associated attributes 
    if (isFirstAssociation)
        object->setHasAssociatedObjects();

    // 19. Change the old value release, If necessary 
    association.releaseHeldValue();
}


     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.
      27.
      28.
      29.
      30.
      31.
      32.
      33.
      34.
      35.
      36.
      37.
      38.
      39.
      40.
      41.
      42.
      43.
      44.
      45.
      46.
      47.
      48.
      49.
      50.
      51.
      52.
      53.
      54.
      55.
      56.
      57.
      58.
      59.
      60.
      61.
      62.
      63.
      64.
      65.
      66.
      67.
      68.
      69.
      70.

You can see , The whole process of associating attributes is very clear , Whether the new value needs retain And whether the old value needs release, It is determined by the correlation strategy ：

enum {
    OBJC_ASSOCIATION_SETTER_ASSIGN      = 0,    // assgin attribute 
    OBJC_ASSOCIATION_SETTER_RETAIN      = 1,    //  When setting the value, you need retain
    OBJC_ASSOCIATION_SETTER_COPY        = 3,    //  When setting the value, you need copy
    OBJC_ASSOCIATION_GETTER_READ        = (0 << 8), // readonly Properties of 
    OBJC_ASSOCIATION_GETTER_RETAIN      = (1 << 8), //  To get the value, you need retain
    OBJC_ASSOCIATION_GETTER_AUTORELEASE = (2 << 8), //  To get the value, you need autorelease
    OBJC_ASSOCIATION_SYSTEM_OBJECT      = _OBJC_ASSOCIATION_SYSTEM_OBJECT, // 1 << 16
};

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.

acquireValue The method is as follows , It just judges whether it is necessary retain and copy, Then call the corresponding function ：

inline void acquireValue() {
    if (_value) {
        switch (_policy & 0xFF) {
        case OBJC_ASSOCIATION_SETTER_RETAIN:
            _value = objc_retain(_value);
            break;
        case OBJC_ASSOCIATION_SETTER_COPY:
            _value = ((id(*)(id, SEL))objc_msgSend)(_value, @selector(copy));
            break;
        }
    }
}

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.

On top of it 8 In step , Have call try_emplace Method to insert data into the table structure , When inserting this function, it will determine whether the data to be inserted exists , Its return value will inform the caller whether the insert operation has occurred , If it already exists , Then this function will do nothing .

3、 ... and . How to get and remove associated attributes

Now? , We have basically understood how Association attributes are set and stored , Then understand that it is very easy to get and remove .

Get the value of the associated attribute by using objc_getAssociatedObject The runtime method implements , This method is implemented as follows ：

We will mainly analyze its call _object_get_associative_reference Internal methods ：

id
_object_get_associative_reference(id object, const void *key)
{
    // 1. Create an associated object structure 
    ObjcAssociation association{};
    {   
        // 2. Get the association manager and global Hash surface 
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        // 3. Try to find the associated properties of the current incoming object 
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            // 4. If the current object has associated attributes , Try to find storage key Whether there is an incoming key
            ObjectAssociationMap &refs = i->second;
            ObjectAssociationMap::iterator j = refs.find(key);
            if (j != refs.end()) {
                // 5. If you can find , Yes association Assign a value 
                association = j->second;
                // 6. According to the Association policy, decide whether to change the returned value retain
                association.retainReturnedValue();
            }
        }
    }
    // 7. Decide whether you need... According to the return policy autorelease, If we don't find out , Returns the nil value 
    return association.autoreleaseReturnedValue();
}

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.

For objects that have been associated with attributes , We can also call objc_removeAssociatedObjects Method to remove all associated attributes , This method is implemented as follows ：

void objc_removeAssociatedObjects(id object) 
{
    //  The object is , And the associated attribute has been marked 
    if (object && object->hasAssociatedObjects()) {
        _object_remove_assocations(object, /*deallocating*/false);
    }
}

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.

_object_remove_assocation The implementation of internal functions is not complicated , The analysis is as follows ：

void
_object_remove_assocations(id object, bool deallocating)
{
    // 1. Create associated objects 
    ObjectAssociationMap refs{};
    {
        // 2. Get the association manager and Hash surface 
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        // 3. Find the associated properties of the incoming object 
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            // 4. After finding , Swap with null 
            refs.swap(i->second);
            // 5. If it is a system object , You need to keep the Association 
            bool didReInsert = false;
            if (!deallocating) {
                for (auto &ref: refs) {
                    if (ref.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
                        i->second.insert(ref);
                        didReInsert = true;
                    }
                }
            }
            // 6. No need to keep associations , Then clear the data directly 
            if (!didReInsert)
                associations.erase(i);
        }
    }
    // 7. The old value is release operation 
    SmallVector<ObjcAssociation *, 4> laterRefs;
    for (auto &i: refs) {
        if (i.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
            // If we are not deallocating, then RELEASE_LATER associations don't get released.
            if (deallocating)
                laterRefs.append(&i.second);
        } else {
            i.second.releaseHeldValue();
        }
    }
    for (auto *later: laterRefs) {
        later->releaseHeldValue();
    }
}

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.
      27.
      28.
      29.
      30.
      31.
      32.
      33.
      34.
      35.
      36.
      37.
      38.
      39.
      40.
      41.
      42.
      43.
      44.

Four . How to manage memory with associated attributes ？

Through the previous introduction , We know that when associating attributes , You can set some options related to memory management through association policies , When setting association properties , If necessary , The old value will be adjusted internally according to the memory management policy release operation , But have you ever thought about , When the normal life cycle of an object ends , How is the memory occupied by these associated attributes recycled ？ This requires us to start from the system dealloc Find the answer in the method .

System objects are destroyed ,dealloc The method will eventually execute to a named objc_destructInstance Inner function of , This function is implemented as follows ：

void *objc_destructInstance(id obj) 
{
    if (obj) {
        bool cxx = obj->hasCxxDtor();
        //  Get whether this object has an associated attribute through the tag 
        bool assoc = obj->hasAssociatedObjects();
        if (cxx) object_cxxDestruct(obj);
        //  Remove the associated attribute of this object 
        if (assoc) _object_remove_assocations(obj, /*deallocating*/true);
        obj->clearDeallocating();
    }

    return obj;
}


     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.

It will determine whether the object to be destroyed has associated attributes , If there is , It will call again to _object_remove_assocation Function to remove the associated attributes , This function was introduced earlier , Internal processing of memory management issues .

5、 ... and . The creation time of association manager and table

In the whole Association attribute implementation scheme , There is another point that we have no closed-loop introduction , That is, the global association manager and Hash How tables are created , When was it created . We only see , When you want to set or get the associated property , Directly get the manager and Hash Table for use , No initialization . Actually , These global data structures are created in runtime Initialization is complete , The process path is as follows ：

1. call runtime Entry function _objc_init

2. Notification call map_images function

3. call map_images_nolock function

4. map_images_nolock It will call arr_init function , This function is implemented as follows ：

void arr_init(void) 
{
    AutoreleasePoolPage::init();
    SideTablesMap.init();
    _objc_associations_init();
    if (DebugScanWeakTables)
        startWeakTableScan();
}

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.

You can see , This function will automatically release the pool , Initialization of logic such as association attributes .

Focus on Technology , love your life , Communication technology , Also be friends .
meanwhile , If you find this article useful , Welcome to share with more friends , Please indicate the source .

原网站

版权声明
本文为[51CTO]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/200/202207171245287423.html