Block源碼解析和深入理解

Block的本質

Block是"帶有自動變量值的匿名函數".

我們通過Clang（LLVM編譯器）來將OC的代碼轉換成C++源碼的形式，通過如下命令：

clang -rewrite-objc 源代碼文件名

下面，我們要轉換的Block語法

int main(int argc, const char * argv[]) {
    void (^blk)(void) = ^{
        printf("Block\n");
    };
    blk();
    return 0;
}

該源代碼通過Clang 可變換為以下形式：

/*
    __block_impl （block）結構體聲明
*/
struct __block_impl {
  void *isa; // isa 指針，指向父類的實例。void * 相當于 id 是個實例。
  int Flags; // 
  int Reserved;
  void *FuncPtr; //函數指針 指向block代碼塊的實現函數
};
/*
    __main_block_impl_0 匿名的block 結構體聲明和實現
*/
struct __main_block_impl_0 {
  struct __block_impl impl;//block 的結構體實例
  struct __main_block_desc_0* Desc; //block des的指針 指向block的詳情
  /*
    __main_block_impl_0 結構體構造函數實現
  */
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock; // 初始化 block 實例屬性 isa ，表示該block 是 _NSConcreteStackBlock (棧)類型的代碼塊
    impl.Flags = flags;
    impl.FuncPtr = fp;// block 具體的函數實現指針
    Desc = desc;//desc 指針
  }
};
/*
     匿名block 具體的函數實現
*/
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Block\n");
    }
/*
    匿名block desc 指針的具體函數實現，對block（__main_block_impl_0） 結構體實例的大小進行初始化
*/
static struct __main_block_desc_0 {
  size_t reserved; // 升級所需區域
  size_t Block_size;//block 實際內存大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

/*
    把多余的轉換去掉，看起來就比較清楚了：
    第一部分：block的初始化
    __main_block_func_0: 參數一 是block語法轉換的C語言函數指針。
    __main_block_desc_0_DATA： 參數二 作為靜態全局變量初始化的 __main_block_desc_0 結構體實例指針
    struct __main_block_impl_0 tmp = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
    struct __main_block_impl_0 *blk = &tmp;
    第二部分：
    block的執行： blk()
    去掉轉化部分：
       (*blk -> imp.FuncPtr)(blk);
    這就是簡單地使用函數指針調用函數。由Block語法轉換的 __main_block_func_0 函數的指針被賦值成員變量FuncPtr中，另外 __main_block_func_0的函數的參數 __cself 指向Block的值，通過源碼可以看出 Block 正式作為參數進行傳遞的。
*/
int main(int argc, const char * argv[]) {
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

針對源碼的解釋大部分在代碼中都注釋了。需要特別指出的是：

static void __main_block_func_0(struct __main_block_impl_0 *__cself)

中的參數 __cself 是指向 __main_block_impl_0 的指針，及匿名block 自身。
擴展：該句源碼類似如 OC 中的方法消息傳遞，OC中每個方法都默認帶兩個參數一個是指向自身的實例self 一個是該方法的SEL 對象。
例如：

    - (void) method: (int)argc{
        NLog(@"%p %d \n",self,arg)
    }

Objective - C 編譯器同C++的方法一樣，也將該方法作為C語言的函數來處理.源碼如下：

/*
    方法中 在轉換成源碼后 自動的添加了self, _cmd兩個參數 
*/
    void _I_MyObjct_method_(struct Myobject *self,SEL _cmd, int arg){
        NSLog (@"%p %d \n",self,arg);
    }

截獲自動變量值（局部變量）

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int val; //局部變量跟block外的類型一直
  const char *fmt; //跟block外的類型一致
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _dmy, int _val, const char *_fmt, int flags=0) : dmy(_dmy), val(_val), fmt(_fmt) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int val = __cself->val; // bound by copy //block 調用外部的局部變量 實際上 相當于Copy 了一份 所以不會影響 局部變量的值 也不能修改值 
  const char *fmt = __cself->fmt; // bound by copy

        printf("Block\n .. ,%d %s",dmy,val,fmt);
    }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
    int dmy = 256; //局部變量 
    int val = 10; // 局部變量
    const char *fmt = "val = %d \n"; //局部變量
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val, fmt));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

源碼解析：block 在調用外部局部變量的時候其實是將外部局部變量 copy了一份使用的所以在沒有任何修飾符的時候是不可以修改外部局部變量的。

__block 說明符

之前的分析中，block 無法改變被截獲的自動變量的值。這樣極為不便：
解決這個問題有兩種方法，
第一種：C 語言中有一個變量，允許block改成值。具體如下：

靜態變量
靜態全局變量
全局變量

雖然Block語法的匿名函數部分簡單的轉換為了C語言函數，但從這個C語言函數中訪問靜態全局，全局變量并沒有任何改變，可直接使用。
但靜態變量的情況，轉換后的函數原本就設置在含有Block語法的函數外，所以無法從變量作用域訪問。
看看這段代碼的源碼：

     int global_val = 1;
     
     static int static_global_val = 2;
     
     int main(int argc, const char * argv[]) {
 
    static int static_val = 3;
    
    void (^blk)(void) = ^{
    
        global_val += 1;
        
        static_global_val += 2;
        
        static_val += 3;
        
        
    };
    
    blk();
    
    return 0;
    
    }

該源代碼中使用了Block 改寫靜態變量靜態全局變量全局變量。該源代碼轉換后如下：

int global_val = 1; //全局變量
 static int static_global_val = 2; //靜態全局變量
            
 struct __main_block_impl_0 {
          struct __block_impl impl;
          struct __main_block_desc_0* Desc;
          int *static_val;//局部靜態變量   --->  可以看出 跟局部變量不同 這邊是接受的指針
          __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, int flags=0) : static_val(_static_val) {
            impl.isa = &_NSConcreteStackBlock;
            impl.Flags = flags;
            impl.FuncPtr = fp;
            Desc = desc;
          }
        };
        static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
          int *static_val = __cself->static_val; // bound by copy // 改代碼跟局部變量 相似，實際上改變的是一個 復制后的指針.但該指針最終指向的 還是最初的變量值。
        
                global_val += 1;
                static_global_val += 2;
                (*static_val) += 3;
        
            }
        
        static struct __main_block_desc_0 {
          size_t reserved;
          size_t Block_size;
        } __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
        int main(int argc, const char * argv[]) {
            static int static_val = 3;
            void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val));
            ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
            return 0;
        }

分析該源碼：發現無論是全局還是靜態全局都可以在Block中直接訪問修改變量值。

然而，靜態局部變量，貌似也可以正常訪問，其調用原理，跟之前的局部變量的調用相似，唯一的不同是，在Block中調用的是指向該變量的指針，并且是賦值了一份指針（但還是最終指向原來的變量）。所以我們可以在Block中改變原理變量的值。
這樣就有個疑問，我們為什么不使用靜態局部變量，來使用去自動變量（局部變量）的訪問呢？
原因：在該靜態局部變量，有變量作用域，當block超出了該作用域，執行的時候，其內部調用的靜態局部變量會被廢棄，我們就無法調用到。因此Block中超出變量作用域而存在的變量同靜態變量一樣，將不能通過指針訪問原來的自動變量。

解決Block 中不能保存值這一問題的第二個方法是使用__block

int main(int argc, const char * argv[]) {
    __block int val = 3;
    void (^blk)(void) = ^{
        val = 1;
    };
    blk();
    return 0;
}

將上面代碼用 clang 轉化后如下：

/*
    __block 轉化成了結構體 
*/
struct __Block_byref_val_0 {
  void *__isa;
__Block_byref_val_0 *__forwarding; //相當于一個指向源變量的指針
 int __flags;
 int __size;
 int val; //相當于源變量
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_val_0 *val; // by ref //持有源變量的結構體實例
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
    impl.isa = &_NSConcreteStackBlock; // block 為棧類型
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_val_0 *val = __cself->val; // bound by ref ；類似于 靜態局部變量 都是copy 一份指向源變量的結構體指針。

        (val->__forwarding->val) = 1;//通過訪問 __block 結構體 成員變量 __forwarding 來訪問源變量
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  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};
int main(int argc, const char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 3};
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

源碼解析：__Block_byref_val_0 結構體實例的成員變量__forwarding持有指向該實例自身的指針。通過成員變量__forwarding訪問成員變量val。（成員變量val是該實例自身持有的變量，它相當于原自動變量）
如圖所示：

Block存儲域
Block 是Objective-C對象。上面我們所創建的block類都為_NSConcreteStackBlock.
由上面我們提到的源碼可以知道：

    impl.isa = &_NSConcreteStackBlock

根據 block 結構體實例的 isa 指針進行分類：

_NSConcreteStackBlock //不難看出其存儲域在棧上
_NSConcreteGlobalBlock // 其存儲域在全局
_NSConcreteMallocBlock // 其存儲域在堆上
詳細分類如圖所示：

_NSConcreteGlobalBlock：存在的情況：

記述全局變量的地方有Block語法時
Block語法的表達式中不使用應截獲的自動變量時

以上情況Block 為全局類對象。除此之外Block語法生成的Block為棧類對象，
例如（一）：

/*
    在下面的block中由于for循環的值 一直在變 所以Block截獲的局部變量一直在變。
*/
    typedef int (^blk_t)(int);
    for (int rate = 0;rate < 10; ++rate){
        blk_t blk = ^(int count){
            return rate * count;
        }
    }

轉化為源碼如下：

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

由此可見雖然block 聲明在全局中，但由于block初始化的時候調用了局部變量，所以該block創建成棧類型的。
_NSConcreteMallocBlock ：存在的情況
在分析之前我們看下之前遺留的問題：

Block 超出變量作用域可存在的原因
__block變量用結構體成員變量__forwarding存在的原因

配置在全局變量上的Block,從變量作用域外也可以通過指針安全的使用。但設置在棧上的Blcok，如果其變量作用域結束，該Block就被廢棄，同樣的__block也配置在棧上，所以其所屬的變量作用域結束，則該__block變量也會被廢棄。
Block提供了將Block和__block變量從棧上復制到堆上的方法來解決這個問題

而__block 變量用結構體成員變量__forwarding可以實現無論__block變量配置在棧上還是堆上都能夠正確的訪問__block變量。

深入理解blocks提供的復制方法究竟是啥？

實際上當ARC有效時，編譯器會進行判斷自動的將block從棧上復制到堆上
如：

    typedef int (^blk_t)(int);
        blk_t func (int count){
            return ^(int count){
                return rate *count;
            };
        }

源碼轉換為：

    blk_t func (int rate)
    {
        blk_t tmp = &__func_block_impl_0(
            _func_block_func_0,&_func_block_desc_0_DATA,rate
        );
        tmp = objc_retainBlock(tmp);
        return objc_autoreleaseReturnValue(tmp);
    }

分析源碼：從源碼來看在ARC狀態下 block復制到堆上實際上其引用計數增加了。

__block變量的存儲域

當block從棧中復制到堆上時，由于block持有__block變量，所以其__blcok變量也會從棧中復制到堆上，所以當block超出作用域調用__block變量也可以成功。這是和靜態局部變量最大的區別。而靜態局部變量，在block從棧中復制到堆上時，由于block不持有變量，所以靜態局部變量不會復制到堆上，其作用域沒變。故出作用域調用會崩潰。
如圖所示：

截獲對象

下面我們將id對象類型的局部變量在block中調用。id類型的對象默認修飾符都是__strong類型的。

typedef void (^blk_t)(id);
blk_t blk;
int main(int argc, const char * argv[]) {
    {
        id array = [[NSMutableArray alloc]init]; // __strong 類型修改的局部變量
        blk = [^(id objc){
            [array addObject:objc];
            NSLog(@"array count = %ld",[array count]);
        } copy];
    }
    blk(@"ww");
    return 0;
}

分析：按理來說 array 對象出了大括號作用域，強引用失效其對象就會廢棄。但改代碼運行正常。那么就意味著，array對象出大括號作用域時，沒有被廢棄，仍能正常訪問。那么是什么原因呢，我們看下Clang之后的源碼.

typedef void (*blk_t)(id);
blk_t blk;

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  id array;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, id _array, int flags=0) : array(_array) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself, id objc) {
  id array = __cself->array; // bound by copy //復制一份指針 賦值

            ((void (*)(id, SEL, ObjectType))(void *)objc_msgSend)((id)array, sel_registerName("addObject:"), (id)objc);
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_0b_9hq6xqxs5gjcxx5j_skhh8n00000gn_T_main_1808b3_mi_0,((NSUInteger (*)(id, SEL))(void *)objc_msgSend)((id)array, sel_registerName("count")));
        }
        /*
                關鍵方法：該方法 相當于ARC 中的 retain方法，將對象的引用計數加一。但該方法除引用計數加一外，還有一個操作就是將block 從棧上復制到堆上，從而可以出作用域，調用id __strong修飾類型的對象。
        */
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}
/*
        dispose 相當于ARC 模式下的 release 將對象的引用計數減一。引用計數減一得同時，將堆上的block 廢棄掉。
*/
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  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};
int main(int argc, const char * argv[]) {
    {
        id array = ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"));
        blk = (blk_t)((id (*)(id, SEL))(void *)objc_msgSend)((id)((void (*)(id))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, array, 570425344)), sel_registerName("copy"));///必須調用block 的copy 方法才能正常運行
    }
    ((void (*)(__block_impl *, id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, (NSString *)&__NSConstantStringImpl__var_folders_0b_9hq6xqxs5gjcxx5j_skhh8n00000gn_T_main_1808b3_mi_1);
    return 0;
}

//從上面的源碼可以發現：前提：當block調用copy方法，從棧中復制到對象，當Block調用的局部變量是個id對象的時候，該對象在block中自動的引用計數加一，并且該block持有該對象，也就是說，對象出了作用域也能被調用，知道block 從堆上廢棄掉為止。如果block 的最后沒有調用copy，那么該對象值，也會隨著作用域的結束而被廢棄。
總結：

什么時候棧上的Block會復制到堆上呢？

調用Block的copy實例方法時。
Block作為函數返回值返回時。
將Block賦值給附有__strong修飾符id類型的類或者Block類型成員變量時。
在方法名中含有usingBlock的cocoa框架方法或者GCD的API中傳遞Block時。

對象和__block的區別？

如果調用對象的Block，沒有調用Copy 或者不在棧上，那么該對象出作用域就會被釋放。
如果調用對象的Block，調用了Copy，或者Block在堆上，那么該對象的作用域跟使用__block修飾的變量的作用域一直，都會被Block所持有，并且生命周期，會隨著Block的廢除，而釋放。

因此當Block中使用對象類型的自動變量時，除以下情形外，推薦調用Block的copy實例方法！！

block作為函數返回值返回時。
Block賦值給類的附加__strong修飾符的id類型或者Block類型的成員變量時。
向方法名中含有usingBlock的Cocoa框架方法或者GCD的API中傳遞Block時。

__block變量和對象

從前面我們看到__block可以修飾任意類型：

當然包括id對象__strong類型了，其原理是相同的：
當 block 從棧上復制到堆上時，__block 所修飾的自動變量也會從棧上復制到堆上，使用_Block_objct_assign函數，持有賦值給__block變量的對象。當 block 廢棄時，__block所修飾的自動變量，也會通過函數_Block_objct_dispose ，釋放掉__block變量的對象。
當__weak修飾符修飾時，由于__weak修飾的自動變量出作用域后會廢棄自動置nil，所以當block調用的時候，其實是調用的nil對象所以不會崩潰，但取不到值。
當__block __weak 同時修飾自動變量時，還是因為__weak（不持有對象）的原因，當 block 從棧上復制到堆上時，__block變量復制到堆上的是一個nil值，所以對該變量進行的操作都是無效的。
當__block 和 __unsafe__unretained 同時修飾變量時，跟__weak不同，當__unsafe__unretained，所修飾的對象邊nil 時該變量不會自動置nil，而是變成野指針，所以當block 從棧上復制到堆上時，實際上__block變量是一個野指針，所以當調用的時候回出錯，導致程序崩潰
__block 和 __autoreleasing 修飾跟上面的__unsafe__unretained是一樣的。

Block 循環引用

存在循環引用的情況：當block對象作為類的屬性或者成員變量，并且在block初始化的時候，調用了self或者self相關類的成員變量。都會引起引用循環。

解決方法：

使用__weak 修飾要截取的自動變量，
當在MRC 中時，可以使用__unsafe_unretained（弊端不會自動置nil 容易出現野指針）修飾。
可以使用__block 修飾，前提是必須執行block代碼塊，而且可以適當地在代碼塊中手動的把__block變量置nil
以下是相關解決方法的實例：
實例一：

    typedef void (^blk_t)(void);
    @interface Myobject : NSObject
    {
        blk_t blk_; //成員變量
        id _objc;//成員變量
    }
    @end
    @implementation MyObject
    - (id)init
    {
        self = [super init];
        /*
            分析改代碼會出現兩種情況的引用循環：
             * 一種是：成員變量block 調用 self，self中持有block ，block中也持有self，導致引用循環，解決方法在之前 加入
             __weak typeof(self) weakSelf = self;
             * 第二中，雖然成員變量block沒有直接調用self ，但其調用了成員變量_objc，所以也會造成引用循環:
             解決方法： __weak id weakObjc = _objc;
        */
        blk_ = ^{
            NSLog(@"self = %@, objc = %@",self,_objc);
        }   
        return self;
    }

實例二：

    typedef void (^blk_t)(void);
    @interface Myobject : NSObject
    {
        blk_t blk_; //成員變量
    }
    @end
    @implementation MyObject
    - (id)init
    {
        self = [super init];
        /*
            此處使用__block修飾變量，是的block 持有__block變量，而__block變量持有MyObject對象，而MyObject持有block對象。出現引用循環：
            然而 當 block執行的時候，__block變量廢棄，從而消除引用循環
        */
    __block id temp = self;
        blk_ = ^{
            NSLog(@"self = %@,,self);
            temp = nil;
        }   
        return self;
    }
    - (void)execBlock
    {
        blk_()
     }
     int main (){
        id o = [[MyObject alloc] init];
        [o execBlock];//必須執行 否則導致引用循環
        return 0;    
     }

總結下__block 和 __weak 之間的優缺點：
使用__block變量的優點:

通過__block 變量可控制對象的持有期間
在不能使用__weak修飾符的環境中不使用__unsafe__unretain修飾符即可（不必擔心野指針）
在執行Block時可動態的決定是否將nil或者其他對象賦值在__block變量中。

使用__block變量的缺點如下：

為避免循環引用必須執行Block

最后編輯于：2017.12.03 05:22:25

?著作權歸作者所有,轉載或內容合作請聯系作者

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 227,572評論 6贊 531
死咒
序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
沈念sama閱讀 98,071評論 3贊 414
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 175,409評論 0贊 373
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 62,569評論 1贊 307
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 71,360評論 6贊 404
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發上，一...
開封第一講書人閱讀 54,895評論 1贊 321
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 42,979評論 3贊 440
雙鴛鴦連環套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
開封第一講書人閱讀 42,123評論 0贊 286
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
沈念sama閱讀 48,643評論 1贊 333
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內容為張勛視角年9月15日...
茶點故事閱讀 40,559評論 3贊 354
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 42,742評論 1贊 369
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 38,250評論 5贊 356
?日本核電站爆炸內幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
茶點故事閱讀 43,981評論 3贊 346
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 34,363評論 0贊 25
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 35,622評論 1贊 280
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 51,354評論 3贊 390
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 47,707評論 2贊 370

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Block源碼解析和深入理解

Block源碼解析和深入理解