久久成人国产av,日本人妻东京热

主要分析了block在持有__block、__weak、__strong修飾的對象時，block結(jié)構(gòu)發(fā)生的變化。

以及block對持有變量的引用計數(shù)造成的具體影響。

思考：

@implementation TestCode
- (void)testFunc {
    @weakify(self)
    self.block111 = ^{
        @strongify(self);
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            if (self) {
                printf("\n\nstrongPerson1 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
            }else{
                printf("self Retain Count = 0 \n");
            }
        });
    };
}

- (void)dealloc {
    printf("\n");
    printf("? 【dealloc】 Retain Count = 0");
}
@end

  
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    TestCode *t = [[TestCode alloc]init];
    [t testFunc];
    
    if (t.block111) {
        t.block111();
    }
}
@end

注意: 以下block111是self所持有的block

如果在block111 中對 NSMutableArray *arrayM 進(jìn)行增刪元素, arrayM是否需要用__block修飾？
在block111 中對weakSelf進(jìn)行 __strong typeof(weakSelf) strongSelf = weakSelf 修飾
- 如果block一直不調(diào)用，那么self是否可以正常銷毀？
- 當(dāng)運行到__strong typeof(weakSelf) strongSelf = weakSelf的下一行時，self引用計數(shù)最少是多少？

一：基本介紹

定義

Block 是帶有自動變量(局部變量)的匿名函數(shù)，是 C 語言的擴(kuò)充功能，其本質(zhì)是一個OC對象。

作為屬性

@property (nonatomic,copy) void(^block)(void);
作為參數(shù)

- (void) getDataWithBlock:(id(^)(id parameter))block;
作為返回值(masonry)

- (MASConstraint * (^)(id))equalTo

結(jié)構(gòu)

- (void)testFunc {
    self.block111 = ^{
        printf("block測試代碼");
    };
    self.block111();
}

把OC代碼轉(zhuǎn)成c++代碼

clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk -fobjc-arc -fobjc-runtime=macosx-10.13 xxxxxx.m

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {
    /// self.block = &__TestCode__testFunc_block_impl_0(A,B)
    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)
     ((id)self, sel_registerName("setBlock111:"),
      (
       (void (*)())&__TestCode__testFunc_block_impl_0
        (
         (void *)__TestCode__testFunc_block_func_0,// 參數(shù)1
         &__TestCode__testFunc_block_desc_0_DATA// 參數(shù)2__TestCode__testFunc_block_desc_0,
        )
       )
     );
    
    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("block111"))();
}

上段代碼的基本意思是

self.block = &__TestCode__testFunc_block_impl_0(A,B)
1. A: __TestCode__testFunc_block_func_0
2. B: __TestCode__testFunc_block_desc_0_DATA

1. TestCodetestFunc_block_impl_0

struct __TestCode__testFunc_block_impl_0 {
  
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
  
  __TestCode__testFunc_block_impl_0(void *fp, struct __TestCode__testFunc_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

命名規(guī)律：_類名_方法名_block_impl_層級

上述代碼中可以看出block 被編譯成了__TestCode__testFunc_block_impl_0結(jié)構(gòu)體

其內(nèi)部有一個同名的構(gòu)造函數(shù)__TestCode__testFunc_block_impl_0
兩個屬性
1. __block_impl impl
2. __TestCode__testFunc_block_desc_0* Desc

2. __block_impl

struct __block_impl {
  void *isa;// 指向了&_NSConcreteStackBlock
  int Flags;
  int Reserved;
  void *FuncPtr; // 用于方法的儲存本質(zhì)是一個 __TestCode__testFunc_block_func_0 c函數(shù)
};

可以發(fā)現(xiàn)__block_impl結(jié)構(gòu)體內(nèi)部就有一個isa指針。因此可以證明block本質(zhì)上就是一個oc對象。

__block_impl結(jié)構(gòu)體中isa指針存儲著&_NSConcreteStackBlock地址，可以暫時理解為其類對象地址，block就是_NSConcreteStackBlock類型的。

看到isa就會聯(lián)想到之前在objc_class結(jié)構(gòu)體，因此我們的block本質(zhì)上也是一個對象【而且是個類對象】
我們知道實例對象->類對象->元類構(gòu)成了isa鏈中的一條，而這個__block_impl結(jié)構(gòu)體占據(jù)的是中間類對象的位置

這里的isa指針會指向元類，這里的元類主要是為了說明這個塊的存儲區(qū)域

__TestCode__testFunc_block_func_0

static void __TestCode__testFunc_block_func_0(struct __TestCode__testFunc_block_impl_0 *__cself) {
        printf("block測試代碼");
}

__TestCode__testFunc_block_func_0 中存放的是block中的代碼

3. TestCodetestFunc_block_desc_0

static struct __TestCode__testFunc_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __TestCode__testFunc_block_desc_0_DATA = { 0, sizeof(struct __TestCode__testFunc_block_impl_0)};

主要是存儲了block的大小

4. 同名的構(gòu)造函數(shù)`TestCodetestFunc_block_impl_0(void fp, struct TestCodetestFunc_block_desc_0 desc, int flags=0)`

__TestCode__testFunc_block_impl_0
    (void *fp, struct __TestCode__testFunc_block_desc_0 *desc, int flags=0)
    {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }

同名函數(shù)主要對兩個屬性進(jìn)行了賦值

void *fp 就是 (void *)__TestCode__testFunc_block_func_0__
__ struct __TestCode__testFunc_block_desc_0 *desc 就是 &__TestCode__testFunc_block_desc_0_DATA

5. 結(jié)構(gòu)圖

image

二：持有變量時block的結(jié)構(gòu)

以上分析的是 block 不持有任何外部變量，但是當(dāng)block持有外部變量的時候，就會額外生成一些東西。

持有基本數(shù)據(jù)類型

持有的基本數(shù)據(jù)類型分為是否用__block修飾，如下，a 用__block修飾，b沒有。

- (void)testFunc {
    __block NSInteger a = 0;
    NSInteger b = 0;
    self.block111 = ^{
        a = 12 + b;
        printf("block測試代碼");
    };
    self.block111();
}

思考

a用__block修飾后可以修改，必然a從值傳遞，變成了地址傳遞。

__blok把a封裝成了什么結(jié)構(gòu)？
結(jié)構(gòu)a的值到底存在哪里？
結(jié)構(gòu)a是怎么管理內(nèi)存的？

要回答上述問題，我們需要查看- (void)testFunc{}編譯的源碼：

編譯后:

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {
    // 結(jié)構(gòu)體 a 的生成  (__block NSInteger a = 0;)
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a =
    {
        (void*)0, // isa
        (__Block_byref_a_0 *)&a,// a地址的傳遞
        0,// flags
        sizeof(__Block_byref_a_0),// size
        0// a的值
    };
    
    NSInteger b = 0;
    
    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)
    ((id)self, sel_registerName("setBlock111:"),
     
     /// 初始化__TestCode__testFunc_block_impl_0結(jié)構(gòu)體
     ((void (*)())&__TestCode__testFunc_block_impl_0
      (
       (void *)__TestCode__testFunc_block_func_0,
       &__TestCode__testFunc_block_desc_0_DATA,
       
       b,//值傳遞b
       (__Block_byref_a_0 *)&a,//把結(jié)構(gòu)體（對象）a的地址傳了進(jìn)去
       
       570425344
       ))
     );
    
    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("block111"))();
}

1. __Block_byref_a_0

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 NSInteger a;
};

// 結(jié)構(gòu)體 a 的生成 
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a =
    {
        (void*)0, // isa
        (__Block_byref_a_0 *)&a,// a地址的傳遞
        0,// flags
        sizeof(__Block_byref_a_0),// size
        0// a的值
    };

用了__block修飾的a，生成了一個用__attribute__ 修飾的 __Block_byref_a_0類型的結(jié)構(gòu)體。
結(jié)構(gòu)體內(nèi)部有一個isa指針,說明__Block_byref_a_0其本質(zhì)也是一個OC對象

2. TestCodetestFunc_block_impl_0結(jié)構(gòu)體

struct __TestCode__testFunc_block_impl_0 {
    
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  NSInteger b;
  __Block_byref_a_0 *a; // by ref
    
  // 同名的構(gòu)造函數(shù)
  __TestCode__testFunc_block_impl_0
    (
     
     void *fp,
     struct __TestCode__testFunc_block_desc_0 *desc,
     NSInteger _b,
     __Block_byref_a_0 *_a,
     int flags=0
     
     ) : b(_b), a(_a->__forwarding) { ... }
};

生成了新的屬性:

NSInteger b
- _b就是棧區(qū)的b
- b 值傳遞
__Block_byref_a_0 *a
- 由于賦值到__TestCode__testFunc_block_impl_0時，傳遞的是棧區(qū)的__Block_byref_a_0 a的地址,所以 _a == &a。
- 因為_a->__forwarding就是&_a因此__TestCode__testFunc_block_impl_0結(jié)構(gòu)體中的a指向的就是棧中的a

小結(jié)論:

block中的b和外部的b,只是值傳遞，因此即便外部修改了b的值，也不會對block的b產(chǎn)生影響。
__block a;把a包裝成了一個結(jié)構(gòu)體,而block內(nèi)部屬性__Block_byref_a_0 *a就是棧區(qū)結(jié)構(gòu)體a的地址
此時， block沒有copy操作，所以block存在棧區(qū)，結(jié)構(gòu)體a也存在棧區(qū)

3. TestCodetestFunc_block_desc_0


static struct __TestCode__testFunc_block_desc_0 {
  size_t reserved;
  size_t Block_size;
   //copy 函數(shù)
  void (*copy)(
    struct __TestCode__testFunc_block_impl_0*, 
    struct __TestCode__testFunc_block_impl_0*
  );
  // dispose 函數(shù)
  void (*dispose)(struct __TestCode__testFunc_block_impl_0*);
    
} __TestCode__testFunc_block_desc_0_DATA = 
                                                                    { 0,// reserved
                                   sizeof(struct __TestCode__testFunc_block_impl_0), //size
                                   __TestCode__testFunc_block_copy_0,//copy
                                   __TestCode__testFunc_block_dispose_0//dispose
                                   };

生成了 copy dispose 函數(shù)

a. TestCodetestFunc_block_copy_0

block被拷貝到堆區(qū)的時候調(diào)用
實現(xiàn)函數(shù)是 _Block_object_assign，它根據(jù)對象的 flags 來判斷是否需要拷貝，或者只是賦值。

// copy
static void __TestCode__testFunc_block_copy_0(struct __TestCode__testFunc_block_impl_0*dst, struct __TestCode__testFunc_block_impl_0*src){
  _Block_object_assign(
                        (void*)&dst->a, 
            (void*)src->a,
            8/*BLOCK_FIELD_IS_BYREF*/
                        );
}

_Block_object_assign

函數(shù)實現(xiàn)在 runtime.c 里

/**
_Block_object_assign參數(shù)flag相關(guān)
                // 是一個對象
        BLOCK_FIELD_IS_OBJECT   =  3, 
        // 是一個block
        BLOCK_FIELD_IS_BLOCK    =  7, 
        // 被__block修飾的變量
        BLOCK_FIELD_IS_BYREF    =  8,  
        // 被__weak修飾的變量，只能被輔助copy函數(shù)使用 
        BLOCK_FIELD_IS_WEAK     = 16,  
        // block輔助函數(shù)調(diào)用（告訴內(nèi)部實現(xiàn)不要進(jìn)行retain或者copy）
        BLOCK_BYREF_CALLER      = 128 
**/

void _Block_object_assign(void *destAddr, const void *object, const int flags) {
  
  // BLOCK_BYREF_CALLER block輔助函數(shù)調(diào)用（告訴內(nèi)部實現(xiàn)不要進(jìn)行retain或者copy）
    if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
      
      //BLOCK_FIELD_IS_WEAK 被__weak修飾的變量，只能被輔助copy函數(shù)使用 
        if ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) {
            _Block_assign_weak(object, destAddr);
        }
        else {
            _Block_assign((void *)object, destAddr);
        }
    }
  
  // 被__block修飾的變量
    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  {
      ///最終走到這邊 
        _Block_byref_assign_copy(destAddr, object, flags);
    }
  
  // 是一個block
    else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) {
        _Block_assign(_Block_copy_internal(object, flags), destAddr);
    }
  
  // 是一個對象
    else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
        _Block_retain_object(object);
        _Block_assign((void *)object, destAddr);
    }
}

/*
Block_private.h
https://opensource.apple.com/source/libclosure/libclosure-73/Block_private.h
*/
 enum {
        BLOCK_DEALLOCATING =      (0x0001),  // runtime
        BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
        BLOCK_NEEDS_FREE =        (1 << 24), // runtime
        BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
        BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
        BLOCK_IS_GC =             (1 << 27), // runtime
        BLOCK_IS_GLOBAL =         (1 << 28), // compiler
        BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
        BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
        BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
    };

struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    int flags; /* refcount; */
    int size;
};


/** runtime.c
http://llvm.org/svn/llvm-project/compiler-rt/trunk/lib/BlocksRuntime/runtime.c
*/
static void *_Block_copy_class = _NSConcreteMallocBlock;
static void *_Block_copy_finalizing_class = _NSConcreteMallocBlock;
static int _Block_copy_flag = BLOCK_NEEDS_FREE;
static int _Byref_flag_initial_value = BLOCK_NEEDS_FREE | 2;

static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {

    struct Block_byref **destp = (struct Block_byref **)dest;
    struct Block_byref *src = (struct Block_byref *)arg;

        //不需要做任何操作
    if (src->forwarding->flags & BLOCK_IS_GC) {
    }
  
        // 需要copy到堆區(qū) 并且需要操作引用計數(shù)
    else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack
        bool isWeak = ((flags & (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK)) == (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK));
        // if its weak ask for an object (only matters under GC)
        struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
        copy->flags = src->flags | _Byref_flag_initial_value; // non-GC one for caller, one for stack
        copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        if (isWeak) {
            copy->isa = &_NSConcreteWeakBlockVariable;  // mark isa field so it gets weak scanning
        }
        if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
            // Trust copy helper to copy everything of interest
            // If more than one field shows up in a byref block this is wrong XXX
            copy->byref_keep = src->byref_keep;
            copy->byref_destroy = src->byref_destroy;
            (*src->byref_keep)(copy, src);
        }
        else {
            // just bits.  Blast 'em using _Block_memmove in case they're __strong
            _Block_memmove(
                (void *)&copy->byref_keep,
                (void *)&src->byref_keep,
                src->size - sizeof(struct Block_byref_header));
        }
    }
    // 已經(jīng)復(fù)制到堆、只操作引用計數(shù)
    else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    // assign byref data block pointer into new Block
    // 其實進(jìn)行了 *destp = src->forwarding 操作，把棧區(qū)的a，變成了 Block_byref *copy
    _Block_assign(src->forwarding, (void **)destp);
}

static void (*_Block_assign)(void *value, void **destptr) = _Block_assign_default;

static void _Block_assign_default(void *value, void **destptr) {
    *destptr = value;
}

省略后的代碼


struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    int flags; /* refcount; */
    int size;
};

static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
    ...
    struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
    copy->flags = src->flags | _Byref_flag_initial_value; // non-GC one for caller, one for stack
    // 堆中拷貝的forwarding指向它自己
    copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)
    // 棧中的forwarding指向堆中的新對象
    src->forwarding = copy;  // patch stack to point to heap copy
    copy->size = src->size;
    ...
     // 其實進(jìn)行了 *destp = src->forwarding 操作，把棧區(qū)的a，變成了 Block_byref *copy
    _Block_assign(src->forwarding, (void **)destp);
}

可以看到，Block_byref 和 __Block_byref_a_0 的前4個成員類型相同，可以互相轉(zhuǎn)化。

b. TestCodetestFunc_block_dispose_0

// dispose
static void __TestCode__testFunc_block_dispose_0(struct __TestCode__testFunc_block_impl_0*src){
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}

_Block_object_dispose

void _Block_object_dispose(const void *object, const int flags) {
    //printf("_Block_object_dispose(%p, %x)\n", object, flags);
    if (flags & BLOCK_FIELD_IS_BYREF)  {
      // 釋放 __block 修飾的變量
        _Block_byref_release(object);
    }
    else if ((flags & (BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_BLOCK) {
                // 釋放block 引用的 block
        _Block_destroy(object);
    }
    else if ((flags & (BLOCK_FIELD_IS_WEAK|BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_OBJECT) {
        // 釋放block 引用的對象
        _Block_release_object(object);
    }
}

static void _Block_byref_release(const void *arg) {
    struct Block_byref *shared_struct = (struct Block_byref *)arg;
    int refcount;

    shared_struct = shared_struct->forwarding;

    if ((shared_struct->flags & BLOCK_NEEDS_FREE) == 0) {
        return; // stack or GC or global
    }
    refcount = shared_struct->flags & BLOCK_REFCOUNT_MASK;
    if (refcount <= 0) {
        printf("_Block_byref_release: Block byref data structure at %p underflowed\n", arg);
    }
    else if ((latching_decr_int(&shared_struct->flags) & BLOCK_REFCOUNT_MASK) == 0) {
        if (shared_struct->flags & BLOCK_HAS_COPY_DISPOSE) {
            (*shared_struct->byref_destroy)(shared_struct);
        }
        _Block_deallocator((struct Block_layout *)shared_struct);
    }
}

static void (*_Block_deallocator)(const void *) = (void (*)(const void *))free;

static int latching_decr_int(int *where) {
    while (1) {
        int old_value = *(volatile int *)where;
        if ((old_value & BLOCK_REFCOUNT_MASK) == BLOCK_REFCOUNT_MASK) {
            return BLOCK_REFCOUNT_MASK;
        }
        if ((old_value & BLOCK_REFCOUNT_MASK) == 0) {
            return 0;
        }
        if (OSAtomicCompareAndSwapInt(old_value, old_value-1, (volatile int *)where)) {
            return old_value-1;
        }
    }
}

被__block修飾的變量，釋放時要用 latching_decr_int函數(shù)減引用計數(shù)，直到計數(shù)為0，就釋放該對象；

而普通的對象、block，就直接釋放銷毀。

小結(jié)：

生成了copy despose函數(shù)。
copy 調(diào)用時機(jī)：
1. 當(dāng)block進(jìn)行copy操作的時候就會自動調(diào)用__TestCode__testFunc_block_desc_0內(nèi)部的__TestCode__testFunc_block_copy_0函數(shù)，__TestCode__testFunc_block_copy_0函數(shù)內(nèi)部會調(diào)用_Block_object_assign函數(shù)。
2. _Block_object_assign內(nèi)部是根據(jù)傳遞的flags類型來對a進(jìn)行copy、retain操作
despose 調(diào)用時機(jī)：
1. 當(dāng)block從堆中移除時就會自動調(diào)用__TestCode__testFunc_block_desc_0中__TestCode__testFunc_block_dispose_0函數(shù)，__TestCode__testFunc_block_dispose_0函數(shù)內(nèi)部會調(diào)用_Block_object_dispose函數(shù)。
2. _Block_object_dispose會對 a做釋放操作，類似于release。

4. TestCodetestFunc_block_func_0

__TestCode__testFunc_block_func_0是__block_impl結(jié)構(gòu)體中存儲的block代碼

static void __TestCode__testFunc_block_func_0(struct __TestCode__testFunc_block_impl_0 *__cself) {
  
  __Block_byref_a_0 *a = __cself->a; // bound by ref
  NSInteger b = __cself->b; // bound by copy
  
  (a->__forwarding->a) = 12 + b;
   printf("block測試代碼");
}

__cself就是我們定義的block

a->__forwarding其實修改的就是我們堆區(qū)的(Block_byref) copy (注意在ARC下我們的block會自動copy)

下圖在TestCode.m中自定義了結(jié)構(gòu)體：

struct __Block_byref_a_0 {
    void *__isa;
    struct __Block_byref_a_0 *__forwarding;
    int __flags;
    int __size;
    NSInteger a;
};
struct __block_impl {
    void *isa;// 指向了&_NSConcreteStackBlock
    int Flags;
    int Reserved;
    void *FuncPtr; // 用于方法的儲存本質(zhì)是一個 __TestCode__testFunc_block_func_0 c函數(shù)
};
struct __TestCode__testFunc_block_impl_0 {
    
    struct __block_impl impl;
    struct __TestCode__testFunc_block_desc_0* Desc;
    struct __Block_byref_a_0 *a; // by ref
};

截屏2020-02-01下午4.30.11.png

5. 結(jié)構(gòu)圖

__block NSInteger a = 0;
NSInteger b = 0;
self.block111 = ^{
    a = 12 + b;
    printf("block測試代碼");
};

image

持有對象類型

對象類型的引用分為三種情況：

用 __block 修飾
用__strong 修飾（@strongify）
用__weak 修飾（@weakify）

??注意下面的代碼產(chǎn)生了循環(huán)引用，隨后會做詳細(xì)的分析

- (void)testFunc {
    
    __weak typeof(self)weakSelf = self;
    __block TestCode *blockSelf = weakSelf;
    
    self.block111 = ^{
        __strong typeof(weakSelf)strongSelf = weakSelf;
        void(^block222)(void) = ^{
            blockSelf = strongSelf;
            printf("\nblock測試代碼\n");
        };
        block222();
    };
    
    self.block111();
}

編譯上述代碼：

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {

    __attribute__((objc_ownership(weak))) typeof(self)weakSelf = self;
    __attribute__((__blocks__(byref))) __Block_byref_blockSelf_0 blockSelf =
    {
        (void*)0,
        (__Block_byref_blockSelf_0 *)&blockSelf,
        33554432,
        sizeof(__Block_byref_blockSelf_0),
        __Block_byref_id_object_copy_131,
        __Block_byref_id_object_dispose_131,
        weakSelf
    };

    // 創(chuàng)建 __TestCode__testFunc_block_impl_1
    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)((id)self, sel_registerName("setBlock111:"), ((void (*)())&__TestCode__testFunc_block_impl_1
     (//參數(shù)：
      (void *)__TestCode__testFunc_block_func_1,
      &__TestCode__testFunc_block_desc_1_DATA,
      weakSelf,
      (__Block_byref_blockSelf_0 *)&blockSelf,
      570425344)
      ));

    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("block111"))();
}

1. __Block_byref_blockSelf_0

struct __Block_byref_blockSelf_0 {
  //【值為：0】[8個字節(jié)]
  void *__isa;
  //【值為&blockSelf】,[8個字節(jié)]
__Block_byref_blockSelf_0 *__forwarding;
  
 int __flags;//【值為33554432】,[4個字節(jié)]
 int __size;//【值為sizeof(__Block_byref_blockSelf_0)】,[4個字節(jié)]
  
  //【__Block_byref_id_object_copy_131】[8個字節(jié)]
 void (*__Block_byref_id_object_copy)(void*, void*);
  //【__Block_byref_id_object_dispose_131】,[8個字節(jié)]
 void (*__Block_byref_id_object_dispose)(void*);
  
 TestCode *__strong blockSelf;//【weakSelf】[8個字節(jié)]
};
/// 共48個字節(jié)

self使用__block修飾后，blockPerson 被包裝成了一個與__Block_byref_a_0相似的結(jié)構(gòu)體

只是比__Block_byref_a_0多了兩個函數(shù)：

__Block_byref_id_object_copy值為__Block_byref_id_object_copy_131
__Block_byref_id_object_dispose值為__Block_byref_id_object_dispose_131

??值得注意的是blockSelf用了__strong修飾，因此產(chǎn)生了循環(huán)引用！需要改成__block typeof(weakSelf)blockSelf = weakSelf; 下面會有詳細(xì)解釋

__Block_byref_id_object_copy_131 與 __Block_byref_id_object_dispose_131

static void __Block_byref_id_object_copy_131(void *dst, void *src) {
 _Block_object_assign((char*)dst + 40, *(void * ) ((char)src + 40), 131);
}
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

內(nèi)部調(diào)用函數(shù)為_Block_object_assign

dst與src就是blockSelf即__Block_byref_blockSelf_0結(jié)構(gòu)體指針

因__Block_byref_blockSelf_0共48個字節(jié)，所以(char*)dst + 40 與(char)src + 40，找到的就是TestCode *__strong blockSelf

最后的flags傳遞的是131 = 3|128 即： BLOCK_FIELD_IS_OBJECT|BLOCK_FIELD_IS_CALLER

調(diào)用時機(jī)：block執(zhí)行copy操作，后面會詳細(xì)分析。

2. TestCodetestFunc_block_impl_1

struct __TestCode__testFunc_block_impl_1 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_1* Desc;
    
  TestCode *const __weak weakSelf;
  __Block_byref_blockSelf_0 *blockSelf; // by ref
    
  __TestCode__testFunc_block_impl_1(
                                    void *fp,
                                    struct __TestCode__testFunc_block_desc_1 *desc,
                                    TestCode *const __weak _weakSelf,
                                    __Block_byref_blockSelf_0 *_blockSelf,
                                    int flags=0
                                    ) : weakSelf(_weakSelf), blockSelf(_blockSelf->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

生成了兩個成員變量：Person *__weak weakPerson;、__Block_byref_blockPerson_0 *blockPerson;

**a. __block_impl impl **

結(jié)構(gòu)沒有任何變化

flags: 570425344表示BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR，即（1<<25 | 1<<29）
FuncPtr: __TestCode__testFunc_block_func_1

3. TestCodetestFunc_block_desc_1

結(jié)構(gòu)沒有任何變化

desc:結(jié)構(gòu)體__TestCode__testFunc_block_desc_1_DATA

static struct __TestCode__testFunc_block_desc_1 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __TestCode__testFunc_block_impl_1*, struct __TestCode__testFunc_block_impl_1*);
  void (*dispose)(struct __TestCode__testFunc_block_impl_1*);
} __TestCode__testFunc_block_desc_1_DATA = {
    0,
    sizeof(struct __TestCode__testFunc_block_impl_1),
    __TestCode__testFunc_block_copy_1,
    __TestCode__testFunc_block_dispose_1
};

值得注意的是：copy、dispose的實現(xiàn)函數(shù)

// copy 函數(shù)
static void __TestCode__testFunc_block_copy_1(struct __TestCode__testFunc_block_impl_1*dst, struct __TestCode__testFunc_block_impl_1*src)
{
    _Block_object_assign((void*)&dst->weakSelf, (void*)src->weakSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);
    _Block_object_assign((void*)&dst->blockSelf, (void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);
}

// dispose 函數(shù)
static void __TestCode__testFunc_block_dispose_1(struct __TestCode__testFunc_block_impl_1*src)
{
    _Block_object_dispose((void*)src->weakSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);
    _Block_object_dispose((void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);
}

a. 對`weakSelf` 的 `_Block_object_assign`操作

void _Block_object_assign(void *destAddr, const void *object, const int flags) {
  
  // BLOCK_BYREF_CALLER block輔助函數(shù)調(diào)用（告訴內(nèi)部實現(xiàn)不要進(jìn)行retain或者copy）
    if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) { ... }
  // 被__block修飾的變量
    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  { ... }
  // 是一個block
    else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) { ... }
  
  // 是一個對象
    else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
        _Block_retain_object(object);
        _Block_assign((void *)object, destAddr);
    }
}

即直接對對象進(jìn)行一個_Block_retain_object操作

但是發(fā)現(xiàn)在ARC下_Block_retain_object函數(shù)并沒有給對象的引用計數(shù)+1。

static void (*_Block_retain_object)(const void *ptr) = _Block_retain_object_default;
static void _Block_retain_object_default(const void *ptr) {
    if (!ptr) return;
}

b. 對`blockSelf`的`_Block_object_assign`操作

最終會調(diào)用到_Block_byref_assign_copy函數(shù)

static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {

    struct Block_byref **destp = (struct Block_byref **)dest;
    struct Block_byref *src = (struct Block_byref *)arg;

        //不需要做任何操作
    if (src->forwarding->flags & BLOCK_IS_GC) {
    }
  
        // 需要copy到堆區(qū) 并且需要操作引用計數(shù)
    else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        bool isWeak = ((flags & (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK)) == (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK));
      
        struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
        copy->flags = src->flags | _Byref_flag_initial_value;
        copy->forwarding = copy; 
        src->forwarding = copy;  
        copy->size = src->size;
      
        if (isWeak) {
            copy->isa = &_NSConcreteWeakBlockVariable;  
        }
        if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
          /// 調(diào)用 __Block_byref_blockSelf_0 中的 __Block_byref_id_object_copy 函數(shù)
                    /// 執(zhí)行byref的byref_keep函數(shù)(即assign函數(shù)，只是會加上BLOCK_BYREF_CALLER標(biāo)志)，管理捕獲的對象內(nèi)存
            copy->byref_keep = src->byref_keep;
            copy->byref_destroy = src->byref_destroy;
            (*src->byref_keep)(copy, src);
        }
        else { ... }
    }
    // 已經(jīng)復(fù)制到堆、只操作引用計數(shù)
    else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) { ... }
    _Block_assign(src->forwarding, (void **)destp);
}

值得注意的是在Block_private.h找到了這個結(jié)構(gòu)：

struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    volatile int32_t flags; // contains ref count
    uint32_t size;
};

struct Block_byref_2 {
    // requires BLOCK_BYREF_HAS_COPY_DISPOSE
    BlockByrefKeepFunction byref_keep;
    BlockByrefDestroyFunction byref_destroy;
};

struct Block_byref_3 {
    // requires BLOCK_BYREF_LAYOUT_EXTENDED
    const char *layout;
};

其實byref_keep就是blockSelf中的__Block_byref_id_object_copy也就是函數(shù)__Block_byref_id_object_copy_131

所以其調(diào)用為

static void __Block_byref_id_object_copy_131(void *dst, void *src) {
 _Block_object_assign((char*)dst + 40, *(void * ) ((char)src + 40), 131);
}
  // 譯為
static void __Block_byref_id_object_copy_131(__Block_byref_blockSelf_0 *dst, __Block_byref_blockSelf_0 *src) {
 _Block_object_assign(
   dst->blockSelf, 
   *(void * )(src->blockSelf), 
   BLOCK_FIELD_IS_OBJECT|BLOCK_FIELD_IS_CALLER
 );
}

繼續(xù)看_Block_object_assign

void _Block_object_assign(void *destAddr, const void *object, const int flags) {
  
  // BLOCK_BYREF_CALLER block輔助函數(shù)調(diào)用（告訴內(nèi)部實現(xiàn)不要進(jìn)行retain或者copy）
    if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
      //BLOCK_FIELD_IS_WEAK 被__weak修飾的變量，只能被輔助copy函數(shù)使用 
        if ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) {
            _Block_assign_weak(object, destAddr);
        }
        else {
            _Block_assign((void *)object, destAddr);
        }
    }
    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  { ... }
    else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) { ... }
    else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) { ... }
}
static void (*_Block_assign)(void *value, void **destptr) = _Block_assign_default;

static void _Block_assign_default(void *value, void **destptr) {
    *destptr = value;
}

運行了_Block_assign函數(shù)，把棧區(qū)的__Block_byref_blockSelf_0 blockSelf賦值成了Block_byref copy

c. 對`weakSelf` 的 `dispose`操作

static void __TestCode__testFunc_block_dispose_1(struct __TestCode__testFunc_block_impl_1*src) 
{
  _Block_object_dispose(
    (void*)src->self, 
    3/*BLOCK_FIELD_IS_OBJECT*/
  );
  _Block_object_dispose(
    (void*)src->blockSelf,
    8/*BLOCK_FIELD_IS_BYREF*/
  );
}

void _Block_object_dispose(const void *object, const int flags) {
    if (flags & BLOCK_FIELD_IS_BYREF)  { ... }
    else if ((flags & (BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_BLOCK) {...}
    else if ((flags & (BLOCK_FIELD_IS_WEAK|BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_OBJECT) {
        // 釋放block 引用的對象
        _Block_release_object(object);
    }
}
static void (*_Block_release_object)(const void *ptr) = _Block_release_object_default;
static void _Block_release_object_default(const void *ptr) {
    if (!ptr) return;
}

可以看到：最終會調(diào)用到_Block_release_object,內(nèi)部也是沒對引用計數(shù)進(jìn)行操作。

d. 對`blockSelf` 的 `dispose`操作

其最終走到了_Block_byref_release函數(shù)：

static void _Block_byref_release(const void *arg) {
    struct Block_byref *shared_struct = (struct Block_byref *)arg;
    int refcount;
    shared_struct = shared_struct->forwarding;
    if ((shared_struct->flags & BLOCK_NEEDS_FREE) == 0) {
        return; 
    }
    refcount = shared_struct->flags & BLOCK_REFCOUNT_MASK;
    if (refcount <= 0) {  }
    else if ((latching_decr_int(&shared_struct->flags) & BLOCK_REFCOUNT_MASK) == 0) {
    /// 主要調(diào)用了
        if (shared_struct->flags & BLOCK_HAS_COPY_DISPOSE) {
            (*shared_struct->byref_destroy)(shared_struct);
        }
        _Block_deallocator((struct Block_layout *)shared_struct);
    }
}

其中__block_release函數(shù)內(nèi)部主要是調(diào)用了(*shared_struct->byref_destroy)(shared_struct)

也就是 __Block_byref_blockSelf_0 *blockSelf 中的__Block_byref_id_object_dispose_131函數(shù)

static void __Block_byref_id_object_dispose_131(void *src) {
     _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

///譯為：
static void __Block_byref_id_object_dispose_131(__Block_byref_blockSelf_0 *src) {
    
  _Block_object_dispose
   (
     *(void * *) (src->blockSelf), 
     BLOCK_FIELD_IS_OBJECT|BLOCK_FIELD_IS_CALLER
   );
}

e. TestCodetestFunc_block_func_1

查看__TestCode__testFunc_block_func_1，函數(shù)中是如何創(chuàng)建第二層block222的

{
  __strong typeof(weakSelf)strongSelf = weakSelf;
        void(^block222)(void) = ^{
            blockSelf = strongSelf;
            printf("\nblock測試代碼\n");
        };
        block222();
}

static void __TestCode__testFunc_block_func_1(struct __TestCode__testFunc_block_impl_1 *__cself) {
    
    __Block_byref_blockSelf_0 *blockSelf = __cself->blockSelf; // bound by ref
    TestCode *const __weak weakSelf = __cself->weakSelf; // bound by copy

    ///__strong typeof(weakSelf)strongSelf = weakSelf;
    __attribute__((objc_ownership(strong))) typeof(weakSelf)strongSelf = weakSelf;
    
    /// 創(chuàng)建block222 即：__TestCode__testFunc_block_impl_0結(jié)構(gòu)體
    void(*block222)(void) = ((void (*)())&__TestCode__testFunc_block_impl_0((void *)__TestCode__testFunc_block_func_0,&__TestCode__testFunc_block_desc_0_DATA,strongSelf,(__Block_byref_blockSelf_0 *)blockSelf,570425344));
  
    /// 調(diào)用: block222()
    ((void (*)(__block_impl *))((__block_impl *)block222)->FuncPtr)((__block_impl *)block222);
}

其中block222是一個__TestCode__testFunc_block_impl_0結(jié)構(gòu)體

4. TestCodetestFunc_block_impl_0

struct __TestCode__testFunc_block_impl_0 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  TestCode *const __strong strongSelf;
  __Block_byref_blockSelf_0 *blockSelf; // by ref
    
  __TestCode__testFunc_block_impl_0(
                                    void *fp,
                                    struct __TestCode__testFunc_block_desc_0 *desc,
                                    TestCode *const __strong _strongSelf,
                                    __Block_byref_blockSelf_0 *_blockSelf,
                                    int flags=0
                                    ) : strongSelf(_strongSelf), blockSelf(_blockSelf->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

其結(jié)構(gòu)和__TestCode__testFunc_block_impl_1結(jié)構(gòu)相似。

只不過blockSelf就是上層block（即：block111）中的 blockSelf

值得注意的是這邊有個TestCode *const __strong strongSelf;

剩下的結(jié)構(gòu)與之前分析的結(jié)構(gòu)大同小異：

static void __TestCode__testFunc_block_func_0(struct __TestCode__testFunc_block_impl_0 *__cself) {
  __Block_byref_blockSelf_0 *blockSelf = __cself->blockSelf; // bound by ref
  TestCode *const __strong strongSelf = __cself->strongSelf; // bound by copy

            (blockSelf->__forwarding->blockSelf) = strongSelf;
            printf("\nblock測試代碼\n");
        }
static void __TestCode__testFunc_block_copy_0(struct __TestCode__testFunc_block_impl_0*dst, struct __TestCode__testFunc_block_impl_0*src) {_Block_object_assign((void*)&dst->blockSelf, (void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->strongSelf, (void*)src->strongSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __TestCode__testFunc_block_dispose_0(struct __TestCode__testFunc_block_impl_0*src) {_Block_object_dispose((void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->strongSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __TestCode__testFunc_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __TestCode__testFunc_block_impl_0*, struct __TestCode__testFunc_block_impl_0*);
  void (*dispose)(struct __TestCode__testFunc_block_impl_0*);
} __TestCode__testFunc_block_desc_0_DATA = { 0, sizeof(struct __TestCode__testFunc_block_impl_0), __TestCode__testFunc_block_copy_0, __TestCode__testFunc_block_dispose_0};

三：持有變量引用計數(shù)操作：

既然在ARC 下copy、dispose函數(shù)都沒有對引用計數(shù)做修改，那么什么時候會對引用計數(shù)進(jìn)行操作?

通過對持有變量的分析、可以總結(jié)出以下特點

1. 用strong 與 weak修飾

- (void)testFunc {
    printf("\n Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __weak typeof (self)weakSelf1 = self;
    printf("\n 【__weak typeof (self)weakSelf】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __weak TestCode *weakSelf2 = self;
    printf("\n 【__weak TestCode *weakSelf2】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __strong typeof(self)strongSelf1 = self;
    printf("\n 【__strong typeof(self)strongSelf1】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __strong TestCode *strongSelf2 = self;
    printf("\n 【__strong TestCode *strongSelf2】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    self.block111 = ^{
        [weakSelf1 class];
        [weakSelf2 class];
        [strongSelf1 class];
        [strongSelf2 class];
    };
}

/** log:
 Retain Count = 1
 【__weak typeof (self)weakSelf】 Retain Count = 1
 【__weak TestCode *weakSelf2】 Retain Count = 1
 【__strong typeof(self)strongSelf1】 Retain Count = 2
 【__strong TestCode *strongSelf2】 Retain Count = 3
*/

編譯后的代碼：

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {
    printf("...");
    
      __attribute__((objc_ownership(weak))) typeof (self)weakSelf1 = self;  
    __attribute__((objc_ownership(weak))) TestCode *weakSelf2 = self;
  
    __attribute__((objc_ownership(strong))) typeof(self)strongSelf1 = self;
    __attribute__((objc_ownership(strong))) TestCode *strongSelf2 = self;

    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)((id)self, sel_registerName("setBlock111:"), ((void (*)())&__TestCode__testFunc_block_impl_0((void *)__TestCode__testFunc_block_func_0, &__TestCode__testFunc_block_desc_0_DATA, strongSelf1, strongSelf2, 570425344)));
}


struct __TestCode__testFunc_block_impl_0 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
 
  TestCode *const __weak weakSelf1;
  TestCode *__weak weakSelf2;
  
  __strong typeof (self) strongSelf1;
  TestCode *__strong strongSelf2;

  // 同名構(gòu)造函數(shù)
  __TestCode__testFunc_block_impl_0(...){ ... }
};

__weak

__weak TestCode *weakSelf1 = self與__weak typeof(self)weakSelf2 = self

最終都調(diào)用了__attribute__((objc_ownership(weak)))

而且__TestCode__testFunc_block_impl_0中對weakSelf1和weakSelf2都是弱引用
__strong

__strong typeof(self)strongSelf1 = self與__strong TestCode *strongSelf2 = self

最終都調(diào)用了__attribute__((objc_ownership(strong)))

而且__TestCode__testFunc_block_impl_0中對strongSelf1和strongSelf2都是強(qiáng)引用

2. 用`__block`修飾的對象

用__block修飾的對象分成兩種寫法

__block TestCode *blockSelf = weakSelf
__block typeof(weakSelf)blockSelf2 = weakSelf


- (void)testFunc {
    printf("\n Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __weak typeof(self)weakSelf = self;
    
    __block TestCode *blockSelf1 = weakSelf;
    printf("\n 【__block TestCode *blockSelf1 = weakSelf】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __block typeof(weakSelf)blockSelf2 = weakSelf;
    printf("\n 【__block typeof(weakSelf)blockSelf2 = weakSelf】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    self.block111 = ^{
        [blockSelf1 class];
        [blockSelf2 class];
    };
}

/**log:
 Retain Count = 1
 【__block TestCode *blockSelf1 = weakSelf】 Retain Count = 2
 【__block typeof(weakSelf)blockSelf2 = weakSelf】 Retain Count = 2
*/

編譯上述代碼：

struct __TestCode__testFunc_block_impl_0 {
  
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  __Block_byref_blockSelf1_0 *blockSelf1; // by ref
  __Block_byref_blockSelf2_1 *blockSelf2; // by ref
  
    // 同名構(gòu)造函數(shù)
  __TestCode__testFunc_block_impl_0(...)  { ...  }
};

struct __Block_byref_blockSelf1_0 {
  void *__isa;
__Block_byref_blockSelf1_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 TestCode *__strong blockSelf1;
};

struct __Block_byref_blockSelf2_1 {
  void *__isa;
__Block_byref_blockSelf2_1 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 typeof (weakSelf) blockSelf2;
};

在__TestCode__testFunc_block_impl_0中生成了兩個成員變量

__block TestCode *blockSelf = weakSelf

TestCode *__strong blockSelf1;對self進(jìn)行了強(qiáng)引用，從而self引用計數(shù)+1,從而產(chǎn)生循環(huán)引用。
__block typeof(weakSelf)blockSelf2 = weakSelf;

typeof (weakSelf) blockSelf2 對self的引用為弱引用，引用計數(shù)沒有+1操作。

3. 補(bǔ)充：

在當(dāng)前作用域中，對self的retainCount加1，退出作用域后減一
1. __block typeof(self)blockSelf = self;
2. __block NSObject *blockSelf = self;
3. __strong typeof (self)strongSelf = self;
4. __strong NSObject *strongSelf = self;
對self的retainCount不作操作
1. __weak typeof(self)weakSelf = self;
2. __weak NSObject *weakSelf = self;

注意 :

用這些修飾語句對對象的引用計數(shù)只在當(dāng)前作用域有效。讓block產(chǎn)生循環(huán)引用的關(guān)鍵在于

__TestCode__testFunc_block_impl_0 block結(jié)構(gòu)體中對對象是否是強(qiáng)引用。

思考答案

@implementation TestCode
- (void)testFunc {
    @weakify(self)
    self.block111 = ^{
        @strongify(self);
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            if (self) {
                printf("\n\nstrongPerson1 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
            }else{
                printf("self Retain Count = 0 \n");
            }
        });
    };
}

- (void)dealloc {
    printf("\n");
    printf("? 【dealloc】 Retain Count = 0");
}
@end

編譯后代碼：

/// block111結(jié)構(gòu)體
struct __TestCode__testFunc_block_impl_1 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_1* Desc;
  
  TestCode *const __weak self_weak_;// 若引用
  
  __TestCode__testFunc_block_impl_1(void *fp, struct __TestCode__testFunc_block_desc_1 *desc, TestCode *const __weak _self_weak_, int flags=0) : self_weak_(_self_weak_) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

///block111中儲存的代碼
static void __TestCode__testFunc_block_func_1(struct __TestCode__testFunc_block_impl_1 *__cself) {
  TestCode *const __weak self_weak_ = __cself->self_weak_; // bound by copy

        try {} catch (...) {}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"
 __attribute__((objc_ownership(strong))) __typeof__(self) self = self_weak_;
#pragma clang diagnostic pop
;
        dispatch_after(dispatch_time((0ull), (int64_t)(2.0 * 1000000000ull)), dispatch_get_main_queue(), ((void (*)())&__TestCode__testFunc_block_impl_0((void *)__TestCode__testFunc_block_func_0, &__TestCode__testFunc_block_desc_0_DATA, self, 570425344)));
    }


/// block222結(jié)構(gòu)體
struct __TestCode__testFunc_block_impl_0 {
    
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  __strong typeof (self) self;/// 強(qiáng)引用
    
  __TestCode__testFunc_block_impl_0(void *fp, struct __TestCode__testFunc_block_desc_0 *desc, __strong typeof (self) _self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

注意：以下block111是self所持有的block

如果在block111 中對 NSMutableArray *arrayM 進(jìn)行增刪元素, arrayM是否需要用__block修飾？

答：不需要，因為并沒有修改arrayM指針?biāo)赶虻牡刂?/p>

在block111 中對weakSelf進(jìn)行 __strong typeof(weakSelf) strongSelf = weakSelf 修飾
- 如果block一直不調(diào)用，那么self是否可以正常銷毀？
  
  答：可以銷毀
  
  因為block調(diào)用的時候，才會創(chuàng)建__TestCode__testFunc_block_impl_0
  
  使得__TestCode__testFunc_block_impl_0內(nèi)部對self進(jìn)行了強(qiáng)引用
  
  從而只要__TestCode__testFunc_block_impl_0不銷毀，self就無法銷毀
- 當(dāng)運行到__strong typeof(weakSelf) strongSelf = weakSelf的下一行時，self引用計數(shù)最少是多少？
  
  答：最少是2
  
  但是出了__strong typeof(weakSelf) strongSelf = weakSelf的作用域，self的引用計數(shù)就會自動減1
判斷void*是否為block類型

BOOL FBObjectIsBlock(void *object) {
    Class blockClass = _BlockClass();

    Class candidate = object_getClass((__bridge id)object);
    return [candidate isSubclassOfClass:blockClass];
}

參考文章

探索 Block 的本質(zhì)
iOS底層原理總結(jié) - 探尋block的本質(zhì)（一）
iOS底層原理總結(jié) - 探尋block的本質(zhì)（二）
iOS Block Part6:block拷貝的實現(xiàn)
OS - Block底層解析
一篇文章剖析block底層源碼以及Block.private
Block_private.h
runtime.c
iOS 中的 block 是如何持有對象的

如果有不對的地方歡迎來噴~

郵箱：15076299703@163.com

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

OC：深入探究 block

思考：

一：基本介紹

定義

結(jié)構(gòu)

1. __TestCode__testFunc_block_impl_0

2. __block_impl

3. __TestCode__testFunc_block_desc_0

4. 同名的構(gòu)造函數(shù)__TestCode__testFunc_block_impl_0(void *fp, struct __TestCode__testFunc_block_desc_0 *desc, int flags=0)

5. 結(jié)構(gòu)圖

二：持有變量時block的結(jié)構(gòu)

持有基本數(shù)據(jù)類型

1. __Block_byref_a_0

2. __TestCode__testFunc_block_impl_0結(jié)構(gòu)體

3. __TestCode__testFunc_block_desc_0

a. __TestCode__testFunc_block_copy_0

_Block_object_assign

b. __TestCode__testFunc_block_dispose_0

_Block_object_dispose

4. __TestCode__testFunc_block_func_0

5. 結(jié)構(gòu)圖

持有對象類型

1. __Block_byref_blockSelf_0

2. __TestCode__testFunc_block_impl_1

3. __TestCode__testFunc_block_desc_1

a. 對weakSelf 的 _Block_object_assign操作

b. 對blockSelf的_Block_object_assign操作

c. 對weakSelf 的 dispose操作

d. 對blockSelf 的 dispose操作

e. __TestCode__testFunc_block_func_1

4. __TestCode__testFunc_block_impl_0

三：持有變量引用計數(shù)操作：

1. 用__strong 與 __weak修飾

2. 用__block修飾的對象

3. 補(bǔ)充：

思考答案

判斷void*是否為block類型

參考文章

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

1. TestCodetestFunc_block_impl_0

3. TestCodetestFunc_block_desc_0

4. 同名的構(gòu)造函數(shù)`TestCodetestFunc_block_impl_0(void fp, struct TestCodetestFunc_block_desc_0 desc, int flags=0)`

2. TestCodetestFunc_block_impl_0結(jié)構(gòu)體

3. TestCodetestFunc_block_desc_0

a. TestCodetestFunc_block_copy_0

b. TestCodetestFunc_block_dispose_0

4. TestCodetestFunc_block_func_0

2. TestCodetestFunc_block_impl_1

3. TestCodetestFunc_block_desc_1

a. 對`weakSelf` 的 `_Block_object_assign`操作

b. 對`blockSelf`的`_Block_object_assign`操作

c. 對`weakSelf` 的 `dispose`操作

d. 對`blockSelf` 的 `dispose`操作

e. TestCodetestFunc_block_func_1

4. TestCodetestFunc_block_impl_0

1. 用strong 與 weak修飾

2. 用`__block`修飾的對象