亚洲色情一区二区不卡,久久任你操,亚洲天堂,久久无码

block本質(zhì)上是封裝了函數(shù)調(diào)用以及函數(shù)調(diào)用環(huán)境的OC對象,為什么這么說呢?我們可以從底層數(shù)據(jù)結(jié)構(gòu)來看.下面是創(chuàng)建一個block然后用clang轉(zhuǎn)換后如下

//OC中的block
 NSObject * (^tempBlock)(NSObject *) = ^ NSObject* (NSObject *argObject) {
            return [[NSObject alloc]init];
        };
        tempBlock([NSObject new]);

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
// block的定義和初始化
 NSObject * (*tempBlock)(NSObject *) = ((NSObject *(*)(NSObject *))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
// block的調(diào)用
        ((NSObject *(*)(__block_impl *, NSObject *))((__block_impl *)tempBlock)->FuncPtr)((__block_impl *)tempBlock, ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("new")));
// block底層實現(xiàn)的結(jié)構(gòu)體
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

從其中可以看出block內(nèi)存布局結(jié)構(gòu)是一個__main_block_impl_0結(jié)構(gòu)體.block有兩個基本變量struct __block_impl impl; struct __main_block_desc_0 Desc,struct __block_impl impl里面放著一個重要的void * isa,還有一個 void * FuncPtr執(zhí)行我們要實現(xiàn)的函數(shù)地址可以看出block是一個OC對象. 下面的struct __main_block_desc_0是block的描述信息比如block的大小,還可能會涉及(void(void,void))copy (void(void,void*))dispose .__main_block_impl_0在兩個基本變量之后可能出會出現(xiàn)捕獲的變量

既然是對象,那么block也會有類型,上面代碼中 impl.isa = &_NSConcreteStackBlock;可以看出,我們也可以通過調(diào)用class方法或者isa指針查看具體類型，最終都是繼承自NSBlock類型
NSGlobalBlock （ _NSConcreteGlobalBlock ）數(shù)據(jù)區(qū)域 .data區(qū)
NSStackBlock （ _NSConcreteStackBlock ）堆區(qū)(從低到高分配內(nèi)存)
NSMallocBlock （ _NSConcreteMallocBlock ）棧區(qū)(從高到低分配內(nèi)存)
通過打印驗證

    NSLog(@"%@", [tempBlock class]);
    NSLog(@"%@", [[tempBlock class] superclass]);
    NSLog(@"%@", [[[tempBlock class] superclass] superclass]);
    NSLog(@"%@", [[[[tempBlock class] superclass] superclass] superclass]);

2020-08-05 14:41:55.193996+0800 study-Block的本質(zhì)[20817:2531218] __NSGlobalBlock__
2020-08-05 14:41:55.194257+0800 study-Block的本質(zhì)[20817:2531218] __NSGlobalBlock
2020-08-05 14:41:55.194274+0800 study-Block的本質(zhì)[20817:2531218] NSBlock
2020-08-05 14:41:55.194291+0800 study-Block的本質(zhì)[20817:2531218] NSObject

也可以看出block是對象,并且isa是從NSObject繼承來的怎樣看這三種類型呢

ARC
  void (^globalBlock)(void) = ^{
            NSLog(@"Hello");
        };
        
        int age = 10;
        void (^mallocBlock)(void) = ^{
            NSLog(@"Hello - %d", age);
        };
        
        NSLog(@"%@ %@ %@", [globalBlock class], [mallocBlock class], [^{
            NSLog(@"%d", age);
        } class]);

輸出
 study-Block的本質(zhì)[20930:2547011]
 __NSGlobalBlock__    
__NSMallocBlock__ 
__NSStackBlock__

block類型分類.png

block的類型是怎樣判定呢?可以這樣判定
在MRC下沒有訪問auto變量是NSGlobalBlock(這種情況很少). 訪問了auto變量是NSStackBlock,NSStackBlock調(diào)用了copy后變成NSMallocBlock.

NSStackBlock棧上的Block存在一些問題,比如

MRC
void (^stack)(void);
void stackFunc()
{
    int age = 10;
    stack = ^{
        NSLog(@"stack-------%d", age);
    };
   
}
int main(int argc, const char *argv[]) {
    
    @autoreleasepool {
        
        stackFunc();
        stack();
    }
    return 0;
}
輸出
stack-------272663488

因為block存儲在棧上,會自動銷毀.函數(shù)調(diào)用完畢后,棧上的東西銷毀, stack捕獲age變成垃圾數(shù)據(jù),出現(xiàn)混亂.所以要把block放到堆上,由我們?nèi)ス芾砜梢允褂?/p>

MRC
int age = 10
  void (^ stack)(void) = [ ^{
        NSLog(@"stack-------%d", age);
    } copy];
變成 __NSMallocBlock__

既然copy可以改變block的存儲區(qū)域那么我們可以嘗試下面

 void (^ global)(void) = [ ^{
        NSLog(@"stack-------%d", age);
    } copy];
NSLog(@"%@",[[global copy] class]);
int age = 10
  void (^ stack)(void) = [ ^{
        NSLog(@"stack-------%d", age);
    } copy];
NSLog(@"%@",[[stack copy] class]);
NSLog(@"%@",[[[stack copy] copy] class]);

上述實踐可以總結(jié)得出: NSStackBlock類型的block復(fù)制之后會從棧復(fù)制到堆
NSGlobalBlock類型的block什么也不做, NSMallocBlock類型的block復(fù)制之后引用計數(shù)加1,所以開發(fā)中要想使用block都會把block保存下來.上述是在MRC下

在ARC環(huán)境下,編譯器會根據(jù)情況自動將棧上的block復(fù)制到堆上
block作為函數(shù)返回值時
將block賦值給__strong指針時
block作為Cocoa API中方法名含有usingBlock的方法參數(shù)時
block作為GCD API的方法參數(shù)時

那么封裝了函數(shù)調(diào)用以及函數(shù)調(diào)用環(huán)境證明呢?我們先看看函數(shù)調(diào)用環(huán)境的封裝,也就是block可能捕獲的變量類型
基本數(shù)據(jù)類型
對于局部變量 block會捕獲到內(nèi)部,以值傳遞的方式進(jìn)行訪問
對于static變量類型,block也會捕獲到內(nèi)部,以指針傳遞的方式進(jìn)行訪問
全局變量不進(jìn)行捕獲直接進(jìn)行訪問

對象類型的auto變量
如果block是在棧上，將不會對auto變量產(chǎn)生強(qiáng)引用
如果block被拷貝到堆上
會調(diào)用block內(nèi)部的copy函數(shù)
copy函數(shù)內(nèi)部會調(diào)用_Block_object_assign函數(shù)
_Block_object_assign函數(shù)會根據(jù)auto變量的修飾符（__strong、__weak、__unsafe_unretained）做出相應(yīng)的操作，形成強(qiáng)引用（retain）或者弱引用
如果block從堆上移除
會調(diào)用block內(nèi)部的dispose函數(shù)
dispose函數(shù)內(nèi)部會調(diào)用_Block_object_dispose函數(shù)
_Block_object_dispose函數(shù)會自動釋放引用的auto變量（release）

對象類型的auto變量什么時候釋放?

       ARCBlock block;
        {
            CXWork *work = [[CXWork alloc]init];
            work.hours = 8;
           block = ^{
                NSLog(@"------%d",work.hours);
            };
        }
        NSLog(@"work是否銷毀------------");

執(zhí)行可以看到work對象并沒有銷毀,我們把下面代碼轉(zhuǎn)成c++看到block對work產(chǎn)生了強(qiáng)引用

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  CXWork *work;//block捕獲的對象類型的auto變量
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, CXWork *_work, int flags=0) : work(_work) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

棧空間上的block不會保住work對象生命,如果是堆空間有能力保住work的生命
如果是下面

       ARCBlock block;
        {
            CXWork *work = [[CXWork alloc]init];
            work.hours = 8;
          __weak CXWork *weakWork = work;
 
           block = ^{
                NSLog(@"------%d", weakWork.hours);
            };
        }
        NSLog(@"work是否銷毀------------");

work會銷毀

ARCBlock block;
        {
            __strong CXWork *work = [[CXWork alloc]init];
            work.hours = 8;
            __weak CXWork *weakWork = work;
            
            block = ^{
                NSLog(@"------%d", weakWork.hours);
            };
        }
        NSLog(@"work是否銷毀------------");
執(zhí)行 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
error: 
      cannot create __weak reference because the current deployment target does
      not support weak references
            __attribute__((objc_ownership(weak))) CXWork *weakWork = work;
修改: __weak修改生成不了C++通過指定arc   runtime版本
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-12.0.0 main.m

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  CXWork *__weak weakWork;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, CXWork *__weak _weakWork, int flags=0) : weakWork(_weakWork) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

當(dāng)block內(nèi)部訪問了對象類型的auto變量時,如果block是在棧上，將不會對auto變量產(chǎn)生強(qiáng)引用.
如果block被拷貝到堆上,ARC下,block被強(qiáng)引用,會自動進(jìn)行copy操作,

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
//訪問對象類型的時候會增加這兩個函數(shù)用于對內(nèi)部訪問的對象進(jìn)行內(nèi)存管理
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
}__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
// 自動根據(jù)捕獲對象 是strong還是weak對weakWork產(chǎn)生強(qiáng)引用或弱引用
_Block_object_assign((void*)&dst->weakWork, (void*)src->weakWork, 3
/*BLOCK_FIELD_IS_OBJECT*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->weakWork, 3/*BLOCK_FIELD_IS_OBJECT*/);}

copy函數(shù)內(nèi)部會調(diào)用_Block_object_assign函數(shù)
_Block_object_assign函數(shù)會根據(jù)auto變量的修飾符（__strong、__weak、__unsafe_unretained）做出相應(yīng)的操作，形成強(qiáng)引用（retain）或者弱引用

_Block_object_assign函數(shù)會對__block變量形成強(qiáng)引用（retain）
當(dāng)block從堆中移除時
會調(diào)用block內(nèi)部的dispose函數(shù)
dispose函數(shù)內(nèi)部會調(diào)用_Block_object_dispose函數(shù)
_Block_object_dispose函數(shù)會自動釋放引用的__block變量（release）

CXWork *work = [[CXWork alloc] init];
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
/// block 對work產(chǎn)生強(qiáng)引用 在執(zhí)行代碼3.0s后釋放
            NSLog(@"-------%@", work);
        });

__weak CXWork *weakWork = work;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
/// block 對weakWork產(chǎn)生弱引用 執(zhí)行代碼weakWork立即釋放
            NSLog(@"-------%@", weakWork);
        });

__block修飾符

void (^ARCBlock)(void)

int main(int argc, const char *argv[]) {

@autoreleasepool {
    int age = 10;
    ARCBlock block = ^{
      // 希望在執(zhí)行block代碼內(nèi)部把a(bǔ)ge改為20
        NSLog(@"-------%d", age);
    };
 block()
}
return 0
}

為什么不能直接改
//block內(nèi)執(zhí)行的代碼 想在__main_block_func_0函數(shù)里修改main函數(shù)里的局部變量 可以看到改不了
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
// block內(nèi)部的age
  int age = __cself->age; // bound by copy

                NSLog((NSString *)&__NSConstantStringImpl__var_folders_51_mgkwq5l143zb9tlp29g09_9w0000gp_T_main_5f654b_mi_0, age);
            }

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
      // 存在于main函數(shù)的?？臻g
        int age = 10;
        ARCBlock block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以把    int age = 10; 改為 static    int age = 10; block會以 int *age的形式捕獲age,所以拿到指針就可以訪問修改對象的內(nèi)存值進(jìn)行修改
也可以用__block修改變量 __block int age = 10;不會像static一樣修改變量的值

__block可以用于解決block內(nèi)部無法修改auto變量值的問題
__block不能修飾全局變量、靜態(tài)變量（static）
編譯器會將__block變量包裝成一個對象


struct __Block_byref_age_0 {
  void *__isa;
__Block_byref_age_0 *__forwarding; // 內(nèi)部的指針指向自己
 int __flags;
 int __size;
 int age; //  外面用到的值存儲在這
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_age_0 *age; // by ref 使用 __block的變化
//fp將來要指向的函數(shù)地址
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
// block執(zhí)行代碼
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_age_0 *age = __cself->age; // bound by ref

                NSLog((NSString *)&__NSConstantStringImpl__var_folders_51_mgkwq5l143zb9tlp29g09_9w0000gp_T_main_9ba40c_mi_0, (age->__forwarding->age));
// age->__forwarding->age 通過指向結(jié)構(gòu)體的指針拿到forwarding在拿到age
            }

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
      // __block int age = 10 的變化
        __attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};

        ARCBlock block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_age_0 *)&age, 570425344));

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

block 內(nèi)部有個指針指向__Block_byref_age_0結(jié)構(gòu)體,結(jié)構(gòu)體內(nèi)部有個成員存儲age,

block修飾對象類型
struct __Block_byref_str_1 {
  void *__isa;
__Block_byref_str_1 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 NSString *str;
};
 __block NSString *str = [[NSString alloc]init];
底層轉(zhuǎn)為結(jié)構(gòu)體__Block_byref_str_1 *str;
在block內(nèi)部賦值
(str->__forwarding->str) = (NSString *)&__NSConstantStringImpl__var_folders_51_mgkwq5l143zb9tlp29g09_9w0000gp_T_main_62a7d7_mi_0;


 NSMutableArray *array = [NSMutableArray array];
    ARCBlock block = ^{
// 拿來用不是修改 不用加block
      [array addObject:@"123"];
     [array addObject:@"456"]
    };
 block()

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

Block基礎(chǔ)

Block基礎(chǔ)

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

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

Block基礎(chǔ)

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

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