//将标签数组根据type以及其他参数进行分组装入数组
- (void)disposeTags:(NSArray *)aryName aryCount:(NSArray *)aryCount{
    NSMutableArray *tags = [NSMutableArray new];//纵向数组
    NSMutableArray *subTags = [NSMutableArray new];//横向数组
    
    float originX = _tagOriginX;
    for (NSString *tagTitle in aryName) {
        NSUInteger index = [aryName indexOfObject:tagTitle];
        
        //计算每个tag的宽度
        CGSize contentSize = [tagTitle fdd_sizeWithFont:[UIFont systemFontOfSize:14] constrainedToSize:CGSizeMake(self.frame.size.width-_tagOriginX*2, MAXFLOAT)];
        
        NSMutableDictionary *dict = [NSMutableDictionary new];
        dict[@"tagTitle"] = tagTitle;//标签标题
        dict[@"tagCount"] =aryCount[index];
        dict[@"viewWith"] = [NSString stringWithFormat:@"%f",contentSize.width+_tagSpace+30];//标签的宽度
        
        if (index == 0) {
            dict[@"originX"] = [NSString stringWithFormat:@"%f",originX];//标签的X坐标
            [subTags addObject:dict];
        } else {
                if (originX + contentSize.width > self.frame.size.width-_tagOriginX*2) {
                    //当前标签的X坐标+当前标签的长度>屏幕的横向总长度则换行
                    [tags addObject:subTags];
                    //换行标签的起点坐标初始化
                    originX = _tagOriginX;
                    dict[@"originX"] = [NSString stringWithFormat:@"%f",originX];//标签的X坐标
                    subTags = [NSMutableArray new];
                    [subTags addObject:dict];
                } else {
                    //如果没有超过屏幕则继续加在前一个数组里
                    dict[@"originX"] = [NSString stringWithFormat:@"%f",originX];//标签的X坐标
                    [subTags addObject:dict];
                }
            }
        
        if (index +1 == aryName.count) {
            //最后一个标签加完将横向数组加到纵向数组中
            [tags addObject:subTags];
            disposeAry = tags;
        }
        
        //标签的X坐标每次都是前一个标签的宽度+标签左右空隙+标签距下个标签的距离
        originX += contentSize.width+_tagHorizontalSpace+_tagSpace+30;
    }
}

#pragma mark - 扩展方法


@implementation NSString (FDDExtention)



- (CGSize)fdd_sizeWithFont:(UIFont *)font constrainedToSize:(CGSize)size {

    CGSize resultSize;

    if ([self respondsToSelector:@selector(boundingRectWithSize:options:attributes:context:)]) {

        NSMethodSignature *signature = [[self class] instanceMethodSignatureForSelector:@selector(boundingRectWithSize:options:attributes:context:)];

        NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];

        [invocation setTarget:self];

        [invocation setSelector:@selector(boundingRectWithSize:options:attributes:context:)];

        NSDictionary *attributes = @{ NSFontAttributeName:font };

        NSStringDrawingOptions options = NSStringDrawingUsesLineFragmentOrigin;

        NSStringDrawingContext *context;

        [invocation setArgument:&size atIndex:2];

        [invocation setArgument:&options atIndex:3];

        [invocation setArgument:&attributes atIndex:4];

        [invocation setArgument:&context atIndex:5];

        [invocation invoke];

        CGRect rect;

        [invocation getReturnValue:&rect];

        resultSize = rect.size;

    } else {

        NSMethodSignature *signature = [[self class] instanceMethodSignatureForSelector:@selector(sizeWithFont:constrainedToSize:)];

        NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];

        [invocation setTarget:self];

        [invocation setSelector:@selector(sizeWithFont:constrainedToSize:)];

        [invocation setArgument:&font atIndex:2];

        [invocation setArgument:&size atIndex:3];

        [invocation invoke];

        [invocation getReturnValue:&resultSize];

    }

    return resultSize;

} 

字符串长度计算完成了，下面就可以进行所有字符串排列的高度了。其实这个蛮简单的 ，统计数组有多少个元素就代表标签排布有多少行。

-(void)setTagAryName:(NSArray *)tagAryName aryCount:(NSArray *)aryCount delegate:(id)delegate{
    _tagDelegate=delegate;
    [self disposeTags:tagAryName aryCount:aryCount];
    UILabel *label=[[UILabel alloc]initWithFrame:CGRectMake(_tagOriginX, 0, 200, 30)];
    label.text=@"事件类别统计：";
    label.textColor=_titleColor;
    label.textAlignment=NSTextAlignmentLeft;
    label.adjustsFontSizeToFitWidth=YES;
    [self addSubview:label];
    //遍历标签数组,将标签显示在界面上,并给每个标签打上tag加以区分
    for (NSArray *iTags in disposeAry) {
        NSUInteger i = [disposeAry indexOfObject:iTags];
        
        for (NSDictionary *tagDic in iTags) {
            NSUInteger j = [iTags indexOfObject:tagDic];
            
            NSString *tagTitle = tagDic[@"tagTitle"];
            float originX = [tagDic[@"originX"] floatValue];
            float viewWith = [tagDic[@"viewWith"] floatValue];
            NSString *count = tagDic[@"tagCount"];
            UIView *NCView=[[UIView alloc]initWithFrame:CGRectMake(originX, _tagOriginY+i*(_tagHeight+_tagVerticalSpace), viewWith, _tagHeight)];
            [self addSubview:NCView];
            UIButton *button = [UIButton buttonWithType:UIButtonTypeCustom];
            button.frame=CGRectMake(0, 0, viewWith-30, _tagHeight);
            button.layer.borderColor = _borderColor.CGColor;
            button.layer.borderWidth = _borderWidth;
            button.layer.masksToBounds = _masksToBounds;
            button.layer.cornerRadius = _cornerRadius;
            button.titleLabel.font = [UIFont systemFontOfSize:_titleSize];
            [button setTitle:tagTitle forState:UIControlStateNormal];
            [button setTitleColor:_titleColor forState:UIControlStateNormal];
            [button setBackgroundImage:_normalBackgroundImage forState:UIControlStateNormal];
            [button setBackgroundImage:_highlightedBackgroundImage forState:UIControlStateHighlighted];
            button.tag = i*iTags.count+j;
            [button addTarget:self action:@selector(buttonAction:) forControlEvents:UIControlEventTouchUpInside];
            UILabel *label=[[UILabel alloc]initWithFrame:CGRectMake(viewWith-30, 0, 30, _tagHeight)];
            label.text=[NSString stringWithFormat:@"X%@",count];
            label.textAlignment=NSTextAlignmentCenter;
            label.adjustsFontSizeToFitWidth=YES;
            label.textColor=_titleColor;
            [NCView addSubview:button];
            [NCView addSubview:label];
        }
    }
    self.countLabel=[[UILabel alloc]initWithFrame:CGRectMake(_tagOriginX, [self getDisposeTagsViewHeight:disposeAry], 100, 30)];
    self.countLabel.text=[NSString stringWithFormat:@"总计：%ld次",_times];
    self.countLabel.textAlignment=NSTextAlignmentLeft;
    self.countLabel.adjustsFontSizeToFitWidth=YES;
    self.countLabel.textColor=_titleColor;
    [self addSubview:self.countLabel];
    if (disposeAry.count > 0) {
            float contentSizeHeight = _tagOriginY+disposeAry.count*(_tagHeight+_tagVerticalSpace);
            self.contentSize = CGSizeMake(self.frame.size.width,contentSizeHeight);
    }
    
    if (self.frame.size.height <= 0) {
        self.frame = CGRectMake(CGRectGetMinX([self frame]), CGRectGetMinY([self frame]), CGRectGetWidth([self frame]), [self getDisposeTagsViewHeight:disposeAry]+30);
    }


}

//计算出全部展示的高度,让maxHeight等于计算出的高度即可,初始化不需要设置高度
NSArray *tagAryCount=@[@"10",@"8",@"7",@"9",@"2",@"4",@"5",@"3",@"4"];
    NSArray* tagAryName = @[@"黑色玫瑰",@"比尔沃吉特",@"钢铁烈阳",@"德玛西亚",@"祖安",@"巨神峰",@"雷瑟守备祖安",@"诺克萨斯暗影岛",@"弗雷尔卓德"];
    ZHLbView * tagsView = [[ZHLbView alloc] initWithFrame:CGRectMake(0, 200, self.view.frame.size.width, 0)];
    [tagsView setTagAryName:tagAryName aryCount:tagAryCount delegate:self];
    [self.view addSubview:tagsView];

OC对象的分类

OC对象主要分为三类：instance(实例对象)，class (类对象)，meta-class（元类对象）

• 
  

  实例对象：

  
  实例对象就是通过类调用alloc来产生的instance，每一次调用的alloc都是产生新的实例对象，内存地址都是不一样的，占据着不同的内存 eg：

        NSObject *objc1 = [[NSObject alloc]init];

        NSObject *objc2 = [[NSObject alloc]init];

        

        NSLog(@"instance----%p %p",objc1,objc2);

        Class Classobjc1 = [objc1 class];

        Class Classobjc2 = [objc2 class];

        Class Classobjc3 = object_getClass(objc1);

        Class Classobjc4 = object_getClass(objc2);

        Class Classobjc5 = [NSObject class];

        NSLog(@"class---%p %p %p %p %p ",Classobjc1,Classobjc2,Classobjc3,Classobjc4,Classobjc5);

• 2.initialize的打印

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

    @autoreleasepool {

        

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 14:59:17.417072+0800 TCCateogry[1616:79391] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

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

    @autoreleasepool {

        

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 15:11:12.246442+0800 TCCateogry[1659:85317] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

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

    @autoreleasepool {

        [TCStudent alloc];

      

    }

    return 0;

}

2020-12-04 15:14:58.705423+0800 TCCateogry[1705:87507] TCPerson (TCtest2) +initialize

2020-12-04 15:14:58.705750+0800 TCCateogry[1705:87507] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

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

    @autoreleasepool {

        [TCPerson alloc];

        [TCPerson alloc];

        [TCStudent alloc];

        [TCStudent alloc];

    }

    return 0;

}

020-12-04 15:23:27.168243+0800 TCCateogry[1731:91248] TCPerson (TCtest2) +initialize

2020-12-04 15:23:27.168601+0800 TCCateogry[1731:91248] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

//+ (void)initialize{

//    NSLog(@"TCStudent +initialize");

//}

@end

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

    @autoreleasepool {

        [TCPerson alloc];   

        [TCStudent alloc];

    }

    return 0;

}

输出结果：

2020-12-04 15:37:09.055459+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

2020-12-04 15:37:09.055775+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

如果子类（子类的分类实现initialize）不实现initialize，则子类的initialize不会调用，调用子类分类的initialize（当然多个分类的话，调用哪个的initialize取决于编译顺序）

类别里面有负载方法么？

• 答：分类里面肯定有负载

#import "TCPerson.h"



@implementation TCPerson

  (void)load{

    

}

@end

#import "TCPerson TCtest1.h"



@implementation TCPerson (TCtest1)

  (void)load{

    

}

@end

#import "TCPerson TCTest2.h"



@implementation TCPerson (TCTest2)

  (void)load{

    

}

@end

load方法什么时候调用？

• 
  

  load方法在运行时加载类和分类的时候调用load

• #import 
  
  
  
  int main(int argc, const char * argv[]) {
  
      @autoreleasepool {
  
          
  
      }
  
      return 0;
  
  }
  
  
  
  

  
  

  @implementation TCPerson
  
  + (void)load{
  
      NSLog(@"TCPerson +load");
  
  }
  
  @end
  
  
  
  
  
  @implementation TCPerson (TCtest1)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest1) +load");
  
  }
  
  @end
  
  @implementation TCPerson (TCTest2)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest2) +load");
  
  }
  
  @end
  
  

  
  

  可以看到我们在main里面不导入任何的头文件，也不引用任何的类，直接运行，控制台输出结果：

  
  

  从输出结果我们可以抛光，三个负载方法都被调用

  
  
  

  如果不是，到底分类的方法是怎么调用的？

  
  

  
  
  • 
    

    首先我们在TCPerson申明一个方法+（void）test和在它的两个分类都重写+（void）test

  #import 
  
  
  
  NS_ASSUME_NONNULL_BEGIN
  
  
  
  @interface TCPerson : NSObject
  
  + (void)test;
  
  @end
  
  
  
  NS_ASSUME_NONNULL_END
  
  
  
  

  
  

  #import "TCPerson.h"
  
  
  
  @implementation TCPerson
  
  + (void)load{
  
      NSLog(@"TCPerson +load");
  
  }
  
  + (void)test{
  
      NSLog(@"TCPerson +test");
  
  }
  
  @end
  
  

  
  

  分类重写测试

  #import "TCPerson+TCtest1.h"
  
  
  
  @implementation TCPerson (TCtest1)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest1) +load");
  
  }
  
  + (void)test{
  
      NSLog(@"TCPerson (TCtest1) +test1");
  
  }
  
  @end
  
  

  
  

  #import "TCPerson+TCTest2.h"
  
  
  
  @implementation TCPerson (TCTest2)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest2) +load");
  
  }
  
  + (void)test{
  
      NSLog(@"TCPerson (TCtest2) +test2");
  
  }
  
  @end
  
  

  
  

  在主要里面我们调用测试

  #import 
  
  #import "TCPerson.h"
  
  int main(int argc, const char * argv[]) {
  
      @autoreleasepool {
  
          [TCPerson test];
  
      }
  
      return 0;
  
  }
  
  

  
  

  输出结果：

  从输出结果中我们可以看到，只有分类2中的测试被调用，为什么只调用分类2中的测试了？
  

  因为编译顺序是分类2在后，1在前，这个时候我们改变编译顺序（进行文件就行了）
  
  其输出结果为：

  细心的老铁会看到，为什么load方法一直都在调用，这是为什么了？它和test方法到底有什么不同了？真的是我们理解中的load不覆盖，test coverage了，所以才出现这种情况么？

  
  

  我们打印TCPerson的类方法

  void printMethodNamesOfClass(Class cls)
  
  {
  
      unsigned int count;
  
      // 获得方法数组
  
      Method *methodList = class_copyMethodList(cls, &count);
  
      
  
      // 存储方法名
  
      NSMutableString *methodNames = [NSMutableString string];
  
      
  
      // 遍历所有的方法
  
      for (int i = 0; i < count; i++) {
  
          // 获得方法
  
          Method method = methodList[I];
  
          // 获得方法名
  
          NSString *methodName = NSStringFromSelector(method_getName(method));
  
          // 拼接方法名
  
          [methodNames appendString:methodName];
  
          [methodNames appendString:@", "];
  
      }
  
      
  
      // 释放
  
      free(methodList);
  
      
  
      // 打印方法名
  
      NSLog(@"%@ %@", cls, methodNames);
  
  }
  
  int main(int argc, const char * argv[]) {
  
      @autoreleasepool {
  
          [TCPerson test];
  
          printMethodNamesOfClass(object_getClass([TCPerson class]));
  
      }
  
      return 0;
  
  }
  
  

  
  

  
  

  
  输出结果：

  
  

  可以看到，TCPerson的所有类方法名，并非覆盖，三个负载，三个测试，方法都在

  载入原始码分析：查看objc长期原始码我们可以看到：

• void call_load_methods(void)
  
  {
  
      static bool loading = NO;
  
      bool more_categories;
  
  
  
      loadMethodLock.assertLocked();
  
  
  
      // Re-entrant calls do nothing; the outermost call will finish the job.
  
      if (loading) return;
  
      loading = YES;
  
  
  
      void *pool = objc_autoreleasePoolPush();
  
  
  
      do {
  
          // 1. Repeatedly call class +loads until there aren't any more
  
          while (loadable_classes_used > 0) {
  
              call_class_loads();
  
          }
  
  
  
          // 2. Call category +loads ONCE
  
          more_categories = call_category_loads();
  
  
  
          // 3. Run more +loads if there are classes OR more untried categories
  
      } while (loadable_classes_used > 0  ||  more_categories);
  
  
  
      objc_autoreleasePoolPop(pool);
  
  
  
      loading = NO;
  
  }
  
  

  
  

  load方法它是先调用 while (loadable_classes_used > 0) {call_class_loads(); }类的load，再调用more_categories = call_category_loads()分类的load，和编译顺序无关，都会调用
  
  我们查看call_class_loads()方法

  static void call_class_loads(void)
  
  {
  
      int I;
  
      
  
      // Detach current loadable list.
  
      struct loadable_class *classes = loadable_classes;
  
      int used = loadable_classes_used;
  
      loadable_classes = nil;
  
      loadable_classes_allocated = 0;
  
      loadable_classes_used = 0;
  
      
  
      // Call all +loads for the detached list.
  
      for (i = 0; i < used; i++) {
  
          Class cls = classes[i].cls;
  
          load_method_t load_method = (load_method_t)classes[i].method;
  
          if (!cls) continue; 
  
  
  
          if (PrintLoading) {
  
              _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
  
          }
  
          (*load_method)(cls, SEL_load);
  
      }
  
      
  
      // Destroy the detached list.
  
      if (classes) free(classes);
  
  }
  
  

  
  

  其通过的是load_method_t函数指针直接调用
  
  函数指针直接调用

  typedef void(*load_method_t)(id, SEL);
  
  

  其分类load方法调用也是一样

  static bool call_category_loads(void)
  
  {
  
      int i, shift;
  
      bool new_categories_added = NO;
  
      
  
      // Detach current loadable list.
  
      struct loadable_category *cats = loadable_categories;
  
      int used = loadable_categories_used;
  
      int allocated = loadable_categories_allocated;
  
      loadable_categories = nil;
  
      loadable_categories_allocated = 0;
  
      loadable_categories_used = 0;
  
  
  
      // Call all +loads for the detached list.
  
      for (i = 0; i < used; i++) {
  
          Category cat = cats[i].cat;
  
          load_method_t load_method = (load_method_t)cats[i].method;
  
          Class cls;
  
          if (!cat) continue;
  
  
  
          cls = _category_getClass(cat);
  
          if (cls  &&  cls->isLoadable()) {
  
              if (PrintLoading) {
  
                  _objc_inform("LOAD: +[%s(%s) load]\n", 
  
                               cls->nameForLogging(), 
  
                               _category_getName(cat));
  
              }
  
              (*load_method)(cls, SEL_load);
  
              cats[i].cat = nil;
  
          }
  
      }
  
  

  
  

  为什么test不一样了

  因为test是因为消息机制调用的，objc_msgSend([TCPerson class], @selector(test));消息机制就牵扯到了isa方法查找，test在元类方法里面顺序查找的（关于isa，可以查看我的实例对象，类对象，元类对象的关联---isa/superclass指针(2)）里面有详细的关于test的方法调用原理

  
  

  load只在加载类的时候调用一次，且先调用类的load，再调用分类的

  
  

  load的继承关系调用
  
  首先我们先看TCStudent

  
  

  #import "TCStudent.h"
  
  
  
  @implementation TCStudent
  
  
  
  @end
  
  

  
  

  不写load方法调用

  TCStudent写上load

• 从中可以看出子类不写load的方法，调用父类的load，当子类调用load时，先调用父类的load，再调用子类的load，父类子类load取决于你写load方法没有，如果都写了，先调用父类的，再调用子类的

  
  

  总结：先调用类的load，如果有子类，则先看子类是否写了load，如果写了，则先调用父类的load，再调用子类的load，当类子类调用完了，再是分类，分类的load取决于编译顺序，先编译，则先调用，test的方法调用走的是消息发送机制，其底层原理和load方法有着本质的区别，消息发送主要取决于isa的方法查找顺序

  
  
  作者：枫紫_6174
  原贴链接：https：//www.jianshu.com/p/f66921e24ffe
  

// 取消
[self.tableView setEditing:YES animated:NO]; 

-(UITableViewCellEditingStyle)tableView:(UITableView *)tableView editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath
{
          // 删除
          return UITableViewCellEditingStyleDelete;
}

-(void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath
{
        //只要实现这个方法，就实现了默认滑动删除！！！！！
        if (editingStyle == UITableViewCellEditingStyleDelete)
        {
            // 删除数据
            [self _deleteSelectIndexPath:indexPath];
        }
}

-(NSString *)tableView:(UITableView *)tableView titleForDeleteConfirmationButtonForRowAtIndexPath:(NSIndexPath *)indexPath
{
          return @"删除";
}

tableView.allowsMultipleSelection = NO;
tableView.allowsSelectionDuringEditing = NO;
tableView.allowsMultipleSelectionDuringEditing = NO;

drawImage方法

drawImage 方法允许在 canvas 中插入其他图像( img 和 canvas 元素) 。drawImage函数有三种函数原型：

drawImage(image, dx, dy) 在画布指定位置绘制原图

drawImage(image, dx, dy, dw, dh) 在画布指定位置上按原图大小绘制指定大小的图

drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh) 剪切图像，并在画布上定位被剪切的部分 从 1.9.0 起支持

参数描述

image

所要绘制的图片资源（网络图片要通过 getImageInfo / downloadFile 先下载）

s

需要绘制到画布中的，image的矩形（裁剪）选择框的左上角 x 坐标

sy

需要绘制到画布中的，image的矩形（裁剪）选择框的左上角 y 坐标

sWidth

需要绘制到画布中的，image的矩形（裁剪）选择框的宽度

sHeight

需要绘制到画布中的，image的矩形（裁剪）选择框的高度

dx

image的左上角在目标 canvas 上 x 轴的位置

dy

image的左上角在目标 canvas 上 y 轴的位置

dWidth

在目标画布上绘制imageResource的宽度，允许对绘制的image进行缩放

dHeight

在目标画布上绘制imageResource的高度，允许对绘制的image进行缩放

// 获取沙盒主目录路径
NSString *homeDir = NSHomeDirectory();
// 获取Documents目录路径
NSString *docDir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
// 获取Library的目录路径
NSString *libDir = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) lastObject];
// 获取Caches目录路径
NSString *cachesDir = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
// 获取tmp目录路径
NSString *tmpDir =  NSTemporaryDirectory();

//获取应用程序程序包中资源文件路径的方法
NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"apple" ofType:@"png"];
UIImage *appleImage = [[UIImage alloc] initWithContentsOfFile:imagePath];

NSArray;  //数组
NSMutableArray;  //可变数组
NSDictionary;  //字典
NSMutableDictionary;  //可变字典
NSData;  //二进制数据
NSMutableData;  //可变二进制数据
NSString;  //字符串
NSMutableString;  //可变字符串
NSNumber;  //基本数据
NSDate;  //日期

/**
 写入数据到plist
 */
- (void)writeToPlist{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSLog(@"写入数据地址%@",path);
    
    NSString *fileName = [path stringByAppendingPathComponent:@"123.plist"];
    NSArray *array = @[@"123", @"王佳佳", @"iOS"];
    //序列化，把数组存入plist文件
    [array writeToFile:fileName atomically:YES];
    NSLog(@"写入成功");
}

/**
 从plist读取数据

 @return 读出数据
 */
- (NSArray *)readFromPlist{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSLog(@"读取数据地址%@",path);
    
    NSString *fileName = [path stringByAppendingPathComponent:@"123.plist"];
    //反序列化，把plist文件数据读取出来，转为数组
    NSArray *result = [NSArray arrayWithContentsOfFile:fileName];
    NSLog(@"%@", result);
    return result;
}

- (void)writeToPreference{
    
    //1.获得NSUserDefaults文件
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    //2.向偏好设置中写入内容
    [userDefaults setObject:@"wangjiajia" forKey:@"name"];
    [userDefaults setBool:YES forKey:@"sex"];
    [userDefaults setInteger:21 forKey:@"age"];
    //2.1立即同步
    [userDefaults synchronize];
    
    NSString *path = NSHomeDirectory();
}

- (void)readFromPreference{
    //获得NSUserDefaults文件
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    
    //读取偏好设置
    NSString *name = [userDefaults objectForKey:@"name"];
    BOOL sex = [userDefaults boolForKey:@"sex"];
    NSInteger age = [userDefaults integerForKey:@"age"];
}

/**
 归档
 */
- (void)keyedArchiver{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSString *file = [path stringByAppendingPathComponent:@"person.data"];
    Person *person = [[Person alloc] init];
    person.name = @"wangjiajia";
    [NSKeyedArchiver archiveRootObject:person toFile:file];
}

/**
 解档
 */
- (void)keyedUnarchiver{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSString *file = [path stringByAppendingPathComponent:@"person.data"];
    Person *person = [NSKeyedUnarchiver unarchiveObjectWithFile:file];
    if (person) {
        NSLog(@"name:%@",person.name);
    }
}

/* 打开数据库 */
int sqlite3_open(
  const char *filename,   /* 数据库路径(UTF-8) */
  sqlite3 **pDb           /* 返回的数据库句柄 */
);

/* 执行没有返回的SQL语句 */
int sqlite3_exec(
  sqlite3 *db,                               /* 数据库句柄 */
  const char *sql,                           /* SQL语句(UTF-8) */
  int (*callback)(void*,int,char**,char**),  /* 回调的C函数指针 */
  void *arg,                                 /* 回调函数的第一个参数 */
  char **errmsg                              /* 返回的错误信息 */
);

/* 执行有返回结果的SQL语句 */
int sqlite3_prepare_v2(
  sqlite3 *db,            /* 数据库句柄 */
  const char *zSql,       /* SQL语句(UTF-8) */
  int nByte,              /* SQL语句最大长度，-1表示SQL支持的最大长度 */
  sqlite3_stmt **ppStmt,  /* 返回的查询结果 */
  const char **pzTail     /* 返回的失败信息*/
);

/* 关闭数据库 */
int sqlite3_close(sqlite3 *db);

#pragma mark - 定位记录的方法
/* 在查询结果中定位到一条记录 */
int sqlite3_step(sqlite3_stmt *stmt);
/* 获取当前定位记录的字段名称数目 */
int sqlite3_column_count(sqlite3_stmt *stmt);
/* 获取当前定位记录的第几个字段名称 */
const char * sqlite3_column_name(sqlite3_stmt *stmt, int iCol);
# pragma mark - 获取字段值的方法
/* 获取二进制数据 */
const void * sqlite3_column_blob(sqlite3_stmt *stmt, int iCol);
/* 获取浮点型数据 */
double sqlite3_column_double(sqlite3_stmt *stmt, int iCol);
/* 获取整数数据 */
int sqlite3_column_int(sqlite3_stmt *stmt, int iCol);
/* 获取文本数据 */
const unsigned char * sqlite3_column_text(sqlite3_stmt *stmt, int iCol);

/* 执行有返回值的SQL语句 */
- (NSArray *)executeQuery:(NSString *)sql{
    NSMutableArray *array = [NSMutableArray array];
    sqlite3_stmt *stmt; //保存查询结果
    //执行SQL语句，返回结果保存在stmt中
    int result = sqlite3_prepare_v2(_database, sql.UTF8String, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        //每次从stmt中获取一条记录，成功返回SQLITE_ROW，直到全部获取完成，就会返回SQLITE_DONE
        while( SQLITE_ROW == sqlite3_step(stmt)) {
            //获取一条记录有多少列
            int columnCount = sqlite3_column_count(stmt);
            //保存一条记录为一个字典
            NSMutableDictionary *dict = [NSMutableDictionary dictionary];
            for (int i = 0; i < columnCount; i++) {
                //获取第i列的字段名称
                const char *name  = sqlite3_column_name(stmt, i);
                //获取第i列的字段值
                const unsigned char *value = sqlite3_column_text(stmt, i);
                //保存进字典
                NSString *nameStr = [NSString stringWithUTF8String:name];
                NSString *valueStr = [NSString stringWithUTF8String:(const char *)value];
                dict[nameStr] = valueStr;
            }
            [array addObject:dict];//添加当前记录的字典存储
        }
        sqlite3_finalize(stmt);//stmt需要手动释放内存
        stmt = NULL;
        NSLog(@"Query Stmt Success");
        return array;
    }
    NSLog(@"Query Stmt Fail");
    return nil;
}

/**
 创建数据库
 */
- (void)createDatabase{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
    NSString *filePath = [path stringByAppendingPathComponent:@"FMDB.db"];
    NSLog(@"数据库路径：%@",filePath);
    /**
     1. 如果该路径下已经存在该数据库，直接获取该数据库;
     2. 如果不存在就创建一个新的数据库;
     3. 如果传@""，会在临时目录创建一个空的数据库，当数据库关闭时，数据库文件也被删除;
     4. 如果传nil，会在内存中临时创建一个空的数据库，当数据库关闭时，数据库文件也被删除;
     */
    self.database = [FMDatabase databaseWithPath:filePath];
}

/* 打开数据库，成功返回YES，失败返回NO */
- (BOOL)open;
/* 关闭数据库，成功返回YES，失败返回NO */
- (BOOL)close;

 /* 1. 直接使用完整的SQL更新语句 */
    [self.database executeUpdate:@"insert into mytable(num,name,sex) values(0,'wangjiajia1','m');"];
    
    NSString *sql = @"insert into mytable(num,name,sex) values(?,?,?);";
    /* 2. 使用不完整的SQL更新语句，里面含有待定字符串"?"，需要后面的参数进行替代 */
    [self.database executeUpdate:sql,@1,@"wangjiajia2",@"m"];
    
    /* 3. 使用不完整的SQL更新语句，里面含有待定字符串"?"，需要数组参数里面的参数进行替代 */
    [self.database executeUpdate:sql
       withArgumentsInArray:@[@2,@"wangjiajia3",@"m"]];
    
    /* 4. SQL语句字符串可以使用字符串格式化，这种我们应该比较熟悉 */
    [self.database executeUpdateWithFormat:@"insert into mytable(num,name,sex) values(%d,%@,%@);",4,@"wangjiajia4",@"m"];

/* 执行查询SQL语句，返回FMResultSet查询结果 */
- (FMResultSet *)executeQuery:(NSString*)sql, ... ;
- (FMResultSet *)executeQueryWithFormat:(NSString*)format, ... ;
- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments;

- (NSArray *)getResultFromDatabase{
    //执行查询SQL语句，返回查询结果
    FMResultSet *result = [self.database executeQuery:@"select * from mytable"];
    NSMutableArray *array = [NSMutableArray array];
    //获取查询结果的下一个记录
    while ([result next]) {
        //根据字段名，获取记录的值，存储到字典中
        NSMutableDictionary *dict = [NSMutableDictionary dictionary];
        int num  = [result intForColumn:@"num"];
        NSString *name = [result stringForColumn:@"name"];
        NSString *sex  = [result stringForColumn:@"sex"];
        dict[@"num"] = @(num);
        dict[@"name"] = name;
        dict[@"sex"] = sex;
        //把字典添加进数组中
        [array addObject:dict];
    }
    return array;
}

//创建多线程安全队列对象
self.queue = [FMDatabaseQueue databaseQueueWithPath:filePath];
//在block块内自行相关数据库操作即可
[self.queue inDatabase:^(FMDatabase * _Nonnull db) {
 }];

//事务
-(void)transaction {
    // 开启事务
    [self.database beginTransaction];
    BOOL isRollBack = NO;
    @try {
        for (int i = 0; i<500; i--) {
            NSNumber *num = @(i+6);
            NSString *name = [[NSString alloc] initWithFormat:@"student_%d",i];
            NSString *sex = (i%2==0)?@"f":@"m";
            NSString *sql = @"insert into mytable(num,name,sex) values(?,?,?);";
            BOOL result = [self.database executeUpdate:sql,num,name,sex];
            if ( !result ) {
                NSLog(@"插入失败！");
                isRollBack = YES;
                return;
            }
        }
    }
    @catch (NSException *exception) {
        isRollBack = YES;
        NSLog(@"插入失败，事务回退");
        // 事务回退
        [self.database rollback];
    }
    @finally {
        if (!isRollBack) {
            NSLog(@"插入成功，事务提交");
            //事务提交
            [self.database commit];
        }else{
            NSLog(@"插入失败，事务回退");
            // 事务回退
            [self.database rollback];
        }
    }
}

//多线程安全事务实例
- (void)transactionByQueue {
    //开启事务
    [self.queue inTransaction:^(FMDatabase *db, BOOL *rollback) {
        BOOL isRollBack = NO;
        for (int i = 0; i<500; i++) {
            NSNumber *num = @(i+1);
            NSString *name = [[NSString alloc] initWithFormat:@"student_%d",i];
            NSString *sex = (i%2==0)?@"f":@"m";
            NSString *sql = @"insert into mytable(num,name,sex) values(?,?,?);";
            BOOL result = [db executeUpdate:sql,num,name,sex];
            if ( !result ) {
                isRollBack = YES;
                return;
            }
        }
        
        //当最后*rollback的值为YES的时候，事务回退，如果最后*rollback为NO，事务提交
        *rollback = isRollBack;
    }];
}

#import 



NS_ASSUME_NONNULL_BEGIN



@interface TCPerson : NSObject



@property (nonatomic, copy) NSString *name;



@end



NS_ASSUME_NONNULL_END

#import "ViewController.h"

#import "TCPerson.h"

@interface ViewController ()

@property (nonatomic, strong) TCPerson *person1;

@end



@implementation ViewController



- (void)viewDidLoad {

    [super viewDidLoad];

    self.person1 = [[TCPerson alloc]init];

    self.person1.name = @"liu yi fei";

    [self.person1 addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];

}



/// 点击屏幕出发改变self.person1的name

/// @param touches touches description

/// @param event event description

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

    self.person1.name = @"cang lao shi";

}



/// 监听回调

/// @param keyPath 监听的属性名字

/// @param object 被监听的对象

/// @param change 改变的新/旧值

/// @param context context description

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{

    NSLog(@"监听到%@对象的%@发生了改变%@",object,keyPath,change);

}



/// 移除观察者

- (void)dealloc{

    [self.person1 removeObserver:self forKeyPath:@"name"];

}

@end

2020-09-24 15:53:52.527734+0800 KVO_TC[9255:98204] 监听到对象的name发生了改变{

    kind = 1;

    new = "cang lao shi";

    old = "liu yi fei";

}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

//    self.person1.name = @"cang lao shi";

    [self.person1 setName:@"cang lao shi"];

}

- (void)setName:(NSString *)name{

    _name = name;

}

#import "ViewController.h"

#import "TCPerson.h"

@interface ViewController ()

@property (nonatomic, strong) TCPerson *person1;

@property (nonatomic, strong) TCPerson *person2;

@end



@implementation ViewController



- (void)viewDidLoad {

    [super viewDidLoad];

    self.person1 = [[TCPerson alloc]init];

    self.person1.name = @"liu yi fei";

    [self.person1 addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];

    

    

    self.person2 = [[TCPerson alloc] init];

    self.person2.name = @"yyyyyyyy";

}



/// 点击屏幕出发改变self.person1的name

/// @param touches touches description

/// @param event event description

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

    self.person1.name = @"cang lao shi";

//    [self.person1 setName:@"cang lao shi"];

    

    self.person2.name = @"ttttttttt";

}



/// 监听回调

/// @param keyPath 监听的属性名字

/// @param object 被监听的对象

/// @param change 改变的新/旧值

/// @param context context description

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{

    NSLog(@"监听到%@对象的%@发生了改变%@",object,keyPath,change);

}



/// 移除观察者

- (void)dealloc{

    [self.person1 removeObserver:self forKeyPath:@"name"];

}

@end

2020-09-24 16:10:36.750153+0800 KVO_TC[9313:105906] 监听到对象的name发生了改变{

    kind = 1;

    new = "cang lao shi";

    old = "liu yi fei";

}

(lldb) p self.person1.isa

(Class) $0 = NSKVONotifying_TCPerson

  Fix-it applied, fixed expression was: 

    self.person1->isa

(lldb) p self.person2.isa

(Class) $1 = TCPerson

  Fix-it applied, fixed expression was: 

    self.person2->isa

(lldb) 

#import "NSKVONotifying_TCPerson.h"



@implementation NSKVONotifying_TCPerson

//NSKVONotifying_TCPerson的set方法实现，其本质来自于foundation框架

- (void)setName:(NSString *)name{

    _NSSetIntVaueAndNotify();

}

//改变过程

void _NSSetIntVaueAndNotify(){

    [self willChangeValueForKey:@"name"];

    [super setName:name];

    [self didChangeValueForKey:@"name"];

}

//通知观察者

- (void)didChangeValueForKey:(NSString *key){

    [observe  observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context];

}

@end

alloc 方法会为对象分配一块内存空间，空间的大小为 isa_t（8 字节）的大小加上所有成员变量所需的空间，再进行一次内存对齐。分配完空间后会初始化 isa_t ，而 isa_t 是一个 union 类型的结构体（或者称之为联合体），它的结构是在 Runtime 里被定义的。

union isa_t {  

    isa_t() { }

    isa_t(uintptr_t value) : bits(value) { }



    Class cls;

    uintptr_t bits;



    struct {

       uintptr_t indexed           : 1;

       uintptr_t has_assoc         : 1;

       uintptr_t has_cxx_dtor      : 1;

       uintptr_t shiftcls          : 33;

       uintptr_t magic             : 6;

       uintptr_t weakly_referenced : 1;

       uintptr_t deallocating      : 1;

       uintptr_t has_sidetable_rc  : 1;

       uintptr_t extra_rc          : 19;

    };

};

从 isa_t 的结构可以看出，isa_t 可以存储 struct，uintptr_t 或者 Class 类型

。

init 方法就直接返回了初始化好的对象，class 指针指向这个初始化好的对象。

也就是在 Runtime 的协助之下，一个对象完成了创建。

你可能想知道，这个对象只存放了一个 isa_t 结构体和成员变量，对象的方法在哪里？

在编译的时候，类在内存中的位置就已经确定，而在 main 方法之前，Runtime 将可执行文件中和动态库所有的符号（Class，Protocol，Selector，IMP，…）加载到内存中，由 Runtime 管理，这里也包括了也是一个对象的类。

类对象里储存着一个 isa_t 的结构体，super_class 指针，cache_t 结构体，class_data_bits_t 指针。

struct objc_class : objc_object {

    isa_t isa;

    Class superclass;

    cache_t cache;            

    class_data_bits_t bits;    

｝

class_data_bits_t 指向类对象的数据区域，数据区域存放着这个类的实例方法链表。而类方法存在元类对象的数据区域。也就是有对象，类对象，元类对象三个概念，对象是在运行时动态创建的，可以有无数个，类对象和元类对象在 main 方法之前创建的，分别只会有一个。

消息分发：

在 Objective-C 中的“方法调用”其实应该叫做消息传递，[object message] 会被编译器翻译为 objc_msgSend(object, @selector(message))，这是一个 C 方法，首先看它的两个参数，第一个是 object ，既方法调用者，第二个参数称为选择子 SEL，Objective-C 为我们维护了一个巨大的选择子表，在使用 @selector() 时会从这个选择子表中根据选择子的名字查找对应的 SEL。如果没有找到，则会生成一个 SEL 并添加到表中，在编译期间会扫描全部的头文件和实现文件将其中的方法以及使用 @selector() 生成的选择子加入到选择子表中。

通过第一个参数 object，可以找到 object 对象的 isa_t 结构体，从上文中能看 isa_t 结构体的结构，在 isa_t 结构体中，shiftcls 存放的是一个 33 位的地址，用于指向 object 对象的类对象，而类对象里有一个 cache_t 结构体，来看一下 cache_t 的具体代码，

struct cache_t {

    struct bucket_t *_buckets;

    mask_t _mask;

    mask_t _occupied;

｝

_mask：分配用来缓存 bucket 的总数。

_occupied：表明目前实际占用的缓存 bucket 的个数。

_buckets：一个散列表，用来方法缓存，bucket_t 类型，包含 key 以及方法实现 IMP。

struct bucket_t {

private:

    cache_key_t _key;

    IMP _imp;

｝

objc_msgSend() 方法会先从缓存表里，查找是否有该 SEL 对应的 IMP，有的话算命中缓存，直接通过函数指针 IMP ，找到方法的具体实现函数，执行。

当然缓存表里可能并不会命中，则此时会根据类对象的 class_data_bits_t 指针找到数据区域，数据区域里用链表存放着类的实例方法，实例方法也是一个结构体，其结构为：

struct method_t {  

    SEL name;

    const char *types;

    IMP imp;

};

编译器将每个方法的返回值和参数类型编码为一个字符串，types 指向的就是这样一个字符串，objc_msgSend() 会在类对象的方法链表里按链表顺序去匹配 SEL，匹配成功则停止，并将此方法加入到类对象的 _buckets 里缓存起来。如果没找到则会通过类对象的 superclass 指针找到其父类，去父类的方法列表里寻找（也会从父类的方法缓存列表开始）。

如果继续没有找到会一直向父类寻找，直到遇见 NSObject，NSObject 的 superclass 指向 nil。也就意味着寻找结束，并没有找到实现方法。（如果这个过程找到了，也同样会在 object 的类对象的 _buckets 里缓存起来）。

选择子在当前类和父类中都没有找到实现，就进入了方法决议（method resolve），首先判断当前 object 的类对象是否实现了 resolveInstanceMethod: 方法，如果实现的话，会调用 resolveInstanceMethod：方法，这个时候我们可以在 resolveInstanceMethod：方法里动态的添加该 SEL 对应的方法（也可以去做点别的，比如写入日志）。之后会重新执行查找方法实现的流程，如果依旧没找到方法，或者没有实现 resolveInstanceMethod: 方法，Runtime 还有另一套机制，消息转发。

消息转发：

消息转发分为以下几步：

1.调用 forwardingTargetForSelector: 方法，尝试找到一个能响应该消息的对象。如果获取到，则直接转发给它。如果返回了 nil，继续下面的动作。

2.调用 methodSignatureForSelector: 方法，尝试获得一个方法签名。如果获取不到，则直接调用 doesNotRecognizeSelector 抛出异常。

3.调用 forwardInvocation: 方法，将第 2 步获取到的方法签名包装成 Invocation 传入，如何处理就在这里面了。

以上三个方法都可以通过在 object 的类对象里实现， forwardingTargetForSelector: 可以通过对参数 SEL 的判断，返回一个可以响应该消息的对象。这样则会重新从该对象开始执行查找方法实现的流程，找到了也同样会在 object 的类对象的 _buckets 里缓存起来。而 2，3 方法则一般是配套使用，实现 methodSignatureForSelector: 方法根据参数 SEL ，做相应处理，返回 NSMethodSignature (方法签名) 对象，NSMethodSignature 对象会被包装成 NSInvocation 对象，forwardInvocation: 方法里就可以对 NSInvocation 进行处理了。

上面是讲的是实例方法，类方法没什么区别，类方法储存在元类对象的数据区域里，通过类对象的 isa_t 找到元类对象，执行查找方法实现的流程，元类对象的 superclass 最终也会指向 NSObject。没找到的话，也会有方法决议以及消息转发。

runtime 可以做什么：

实现多继承：从 forwardingTargetForSelector: 方法就能知道，一个类可以做到继承多个类的效果，只需要在这一步将消息转发给正确的类对象就可以模拟多继承的效果。

交换两个方法的实现：

    Method m1 = class_getInstanceMethod([M1 class], @selector(hello1));

    Method m2 = class_getInstanceMethod([M2 class], @selector(hello2));

    method_exchangeImplementations(m2, m1);

关联对象：

通过下面两个方法，可以给 category 实现添加成员变量的效果。

objc_setAssociatedObject

objc_getAssociatedObject

动态添加类和方法：

objc_allocateClassPair 函数与 objc_registerClassPair 函数可以完成一个新类的添加，class_addMethod 给类添加方法，class_addIvar 添加成员变量，objc_registerClassPair 来注册类，其中成员变量的添加必须在类注册之前，类注册后就可以创建该类的对象了，而再添加成员变量就会破坏创建的对象的内存结构。

将 json 转换为 model：

用到了 Runtime 获取某一个类的全部属性的名字，以及 Runtime 获取属性的类型。

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),

            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));

}

public static int getDefaultSize(int size, int measureSpec) {    int result = size;

    int specMode = MeasureSpec.getMode(measureSpec);

    int specSize = MeasureSpec.getSize(measureSpec);



    switch (specMode) {

    case MeasureSpec.UNSPECIFIED:

        result = size;

        break;

    case MeasureSpec.AT_MOST:

    case MeasureSpec.EXACTLY:

        result = specSize;

        break;

    }

    return result;

}

protected int getSuggestedMinimumWidth() {    return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());

}

public int getMinimumWidth() {    final int intrinsicWidth = getIntrinsicWidth();

    return intrinsicWidth > 0 ? intrinsicWidth : 0;

}

protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {    final int size = mChildrenCount;

    final View[] children = mChildren;

    for (int i = 0; i < size; ++i) {

        final View child = children[i];

        if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {

            measureChild(child, widthMeasureSpec, heightMeasureSpec);

        }

    }

}





protected void measureChild(View child, int parentWidthMeasureSpec,

        int parentHeightMeasureSpec) {

    final LayoutParams lp = child.getLayoutParams();



    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,

            mPaddingLeft + mPaddingRight, lp.width);

    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,

            mPaddingTop + mPaddingBottom, lp.height);



    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

}

public void layout(int l, int t, int r, int b) {    if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {

        onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);

        mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;

    }



    int oldL = mLeft;

    int oldT = mTop;

    int oldB = mBottom;

    int oldR = mRight;



    boolean changed = isLayoutModeOptical(mParent) ?

            setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);



    if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {

        onLayout(changed, l, t, r, b);



        if (shouldDrawRoundScrollbar()) {

            if(mRoundScrollbarRenderer == null) {

                mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);

            }

        } else {

            mRoundScrollbarRenderer = null;

        }



        mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;



        ListenerInfo li = mListenerInfo;

        if (li != null && li.mOnLayoutChangeListeners != null) {

            ArrayList listenersCopy =

                    (ArrayList)li.mOnLayoutChangeListeners.clone();

            int numListeners = listenersCopy.size();

            for (int i = 0; i < numListeners; ++i) {

                listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);

            }

        }

    }



    final boolean wasLayoutValid = isLayoutValid();



    mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;

    mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;



    if (!wasLayoutValid && isFocused()) {

        mPrivateFlags &= ~PFLAG_WANTS_FOCUS;

        if (canTakeFocus()) {

            // We have a robust focus, so parents should no longer be wanting focus.

            clearParentsWantFocus();

        } else if (getViewRootImpl() == null || !getViewRootImpl().isInLayout()) {

            // This is a weird case. Most-likely the user, rather than ViewRootImpl, called

            // layout. In this case, there's no guarantee that parent layouts will be evaluated

            // and thus the safest action is to clear focus here.

            clearFocusInternal(null, /* propagate */ true, /* refocus */ false);

            clearParentsWantFocus();

        } else if (!hasParentWantsFocus()) {

            // original requestFocus was likely on this view directly, so just clear focus

            clearFocusInternal(null, /* propagate */ true, /* refocus */ false);

        }

        // otherwise, we let parents handle re-assigning focus during their layout passes.

    } else if ((mPrivateFlags & PFLAG_WANTS_FOCUS) != 0) {

        mPrivateFlags &= ~PFLAG_WANTS_FOCUS;

        View focused = findFocus();

        if (focused != null) {

            // Try to restore focus as close as possible to our starting focus.

            if (!restoreDefaultFocus() && !hasParentWantsFocus()) {

                // Give up and clear focus once we've reached the top-most parent which wants

                // focus.

                focused.clearFocusInternal(null, /* propagate */ true, /* refocus */ false);

            }

        }

    }



    if ((mPrivateFlags3 & PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT) != 0) {

        mPrivateFlags3 &= ~PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT;

        notifyEnterOrExitForAutoFillIfNeeded(true);

    }

}

 private void performDraw() {



    boolean canUseAsync = draw(fullRedrawNeeded);

  }



  private boolean draw(boolean fullRedrawNeeded) {

    ...

    if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,

                        scalingRequired, dirty, surfaceInsets)) {

      return false;

    }

  }



  private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,

            boolean scalingRequired, Rect dirty, Rect surfaceInsets) {

     ...

     mView.draw(canvas);

     ...

  }

public void setContentView(@LayoutRes int layoutResID) {


    getWindow().setContentView(layoutResID);

    initWindowDecorActionBar();

}



public Window getWindow() {

    return mWindow;

}

final void attach(Context context, ActivityThread aThread,        Instrumentation instr, IBinder token, int ident,

        Application application, Intent intent, ActivityInfo info,

        CharSequence title, Activity parent, String id,

        NonConfigurationInstances lastNonConfigurationInstances,

        Configuration config, String referrer, IVoiceInteractor voiceInteractor,

        Window window, ActivityConfigCallback activityConfigCallback) {

    attachBaseContext(context);



    mFragments.attachHost(null /*parent*/);



    mWindow = new PhoneWindow(this, window, activityConfigCallback);

    mWindow.setWindowControllerCallback(this);

    mWindow.setCallback(this);

    mWindow.setOnWindowDismissedCallback(this);

    mWindow.getLayoutInflater().setPrivateFactory(this);

    

    ......

}

@Overridepublic void setContentView(int layoutResID) {



    // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window

    // decor, when theme attributes and the like are crystalized. Do not check the feature

    // before this happens.

    if (mContentParent == null) {

        installDecor();  //在这里

    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {

        mContentParent.removeAllViews();

    }



    if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {

        final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,

                getContext());

        transitionTo(newScene);

    } else {

        mLayoutInflater.inflate(layoutResID, mContentParent);

    }

    mContentParent.requestApplyInsets();

    final Callback cb = getCallback();

    if (cb != null && !isDestroyed()) {

        cb.onContentChanged();

    }

    mContentParentExplicitlySet = true;

}

private void installDecor() {    mForceDecorInstall = false;

    if (mDecor == null) {

        mDecor = generateDecor(-1); //注释1

        mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);

        mDecor.setIsRootNamespace(true);

        if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {

            mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);

        }

    } else {

        mDecor.setWindow(this);

    }

    if (mContentParent == null) {

        mContentParent = generateLayout(mDecor);    //注释2



        ......

    }

}

protected DecorView generateDecor(int featureId) {


    // System process doesn't have application context and in that case we need to directly use

    // the context we have. Otherwise we want the application context, so we don't cling to the

    // activity.

    Context context;

    if (mUseDecorContext) {

        Context applicationContext = getContext().getApplicationContext();

        if (applicationContext == null) {

            context = getContext();

        } else {

            context = new DecorContext(applicationContext, getContext());

            if (mTheme != -1) {

                context.setTheme(mTheme);

            }

        }

    } else {

        context = getContext();

    }

    return new DecorView(context, featureId, this, getAttributes());

}

    

protected ViewGroup generateLayout(DecorView decor) {


    ......



    // Inflate the window decor.

    //根据不同情况加载不同的布局给layoutResource

    

    int layoutResource;

    int features = getLocalFeatures();

    // System.out.println("Features: 0x" + Integer.toHexString(features));

    if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {

        layoutResource = R.layout.screen_swipe_dismiss;

        setCloseOnSwipeEnabled(true);

    } else if ((features & ((1 << FEATURE_LEFT_ICON) | (1 << FEATURE_RIGHT_ICON))) != 0) {

        if (mIsFloating) {

            TypedValue res = new TypedValue();

            getContext().getTheme().resolveAttribute(

                    R.attr.dialogTitleIconsDecorLayout, res, true);

            layoutResource = res.resourceId;

        } else {

            layoutResource = R.layout.screen_title_icons;

        }

        // XXX Remove this once action bar supports these features.

        removeFeature(FEATURE_ACTION_BAR);

        // System.out.println("Title Icons!");

    } else if ((features & ((1 << FEATURE_PROGRESS) | (1 << FEATURE_INDETERMINATE_PROGRESS))) != 0

            && (features & (1 << FEATURE_ACTION_BAR)) == 0) {

        // Special case for a window with only a progress bar (and title).

        // XXX Need to have a no-title version of embedded windows.

        layoutResource = R.layout.screen_progress;

        // System.out.println("Progress!");

    } else if ((features & (1 << FEATURE_CUSTOM_TITLE)) != 0) {

        // Special case for a window with a custom title.

        // If the window is floating, we need a dialog layout

        if (mIsFloating) {

            TypedValue res = new TypedValue();

            getContext().getTheme().resolveAttribute(

                    R.attr.dialogCustomTitleDecorLayout, res, true);

            layoutResource = res.resourceId;

        } else {

            layoutResource = R.layout.screen_custom_title;

        }

        // XXX Remove this once action bar supports these features.

        removeFeature(FEATURE_ACTION_BAR);

    } else if ((features & (1 << FEATURE_NO_TITLE)) == 0) {

        // If no other features and not embedded, only need a title.

        // If the window is floating, we need a dialog layout

        if (mIsFloating) {

            TypedValue res = new TypedValue();

            getContext().getTheme().resolveAttribute(

                    R.attr.dialogTitleDecorLayout, res, true);

            layoutResource = res.resourceId;

        } else if ((features & (1 << FEATURE_ACTION_BAR)) != 0) {

            layoutResource = a.getResourceId(

                    R.styleable.Window_windowActionBarFullscreenDecorLayout,

                    R.layout.screen_action_bar);

        } else {

            layoutResource = R.layout.screen_title; //在这里！！！！！！！ 

        }

        // System.out.println("Title!");

    } else if ((features & (1 << FEATURE_ACTION_MODE_OVERLAY)) != 0) {

        layoutResource = R.layout.screen_simple_overlay_action_mode;

    } else {

        // Embedded, so no decoration is needed.

        layoutResource = R.layout.screen_simple;

        // System.out.println("Simple!");

    }



    ......



    mDecor.finishChanging();



    return contentParent;

}

public static class MeasureSpec {    private static final int MODE_SHIFT = 30;

    private static final int MODE_MASK  = 0x3 << MODE_SHIFT;



    ......

    

    public static final int UNSPECIFIED = 0 << MODE_SHIFT;



    public static final int EXACTLY     = 1 << MODE_SHIFT;

    

    public static final int AT_MOST     = 2 << MODE_SHIFT;

    

    public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,

                                      @MeasureSpecMode int mode) {

        if (sUseBrokenMakeMeasureSpec) {

            return size + mode;

        } else {

            return (size & ~MODE_MASK) | (mode & MODE_MASK);

        }

    }



    public static int makeSafeMeasureSpec(int size, int mode) {

        if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {

            return 0;

        }

        return makeMeasureSpec(size, mode);

    }



    

    @MeasureSpecMode

    public static int getMode(int measureSpec) {

        //noinspection ResourceType

        return (measureSpec & MODE_MASK);

    }



    

    public static int getSize(int measureSpec) {

        return (measureSpec & ~MODE_MASK);

    }



    static int adjust(int measureSpec, int delta) {

        final int mode = getMode(measureSpec);

        int size = getSize(measureSpec);

        if (mode == UNSPECIFIED) {

            // No need to adjust size for UNSPECIFIED mode.

            return makeMeasureSpec(size, UNSPECIFIED);

        }

        size += delta;

        if (size < 0) {

            Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +

                    ") spec: " + toString(measureSpec) + " delta: " + delta);

            size = 0;

        }

        return makeMeasureSpec(size, mode);

    }



    

    ......

}

ThreadPoolExecutor介绍

可以通过ThreadPoolExecutor开创建一个线程池，ThreadPoolExecutor类一共有四个构造方法。下面展示的都是拥有最多参数的的构造方法。

public ThreadPoolExecutor(int corePoolSize,
                         int maximumPoolSize,

                          long keepAliveTime,

                          TimeUnit unit,

                          BlockingQueue workQueue,

                          ThreadFactory threadFactory,

                          RejectedExecutionHandler handler) {

    if (corePoolSize < 0 ||

        maximumPoolSize <= 0 ||

        maximumPoolSize < corePoolSize ||

        keepAliveTime < 0)

        throw new IllegalArgumentException();

    if (workQueue == null || threadFactory == null || handler == null)

        throw new NullPointerException();

    this.corePoolSize = corePoolSize;

    this.maximumPoolSize = maximumPoolSize;

    this.workQueue = workQueue;

    this.keepAliveTime = unit.toNanos(keepAliveTime);

    this.threadFactory = threadFactory;

    this.handler = handler;

}

• corePoolSize：核心线程数。默认情况下线程池是空的，只有任务提交时才会创建线程。如果当前运行的线程数少于corePoolSize，则会创建新线程来处理任务；如果等于或者多于corePoolSize，则不会创建，如果调用线程池的prestartAllcoreThread()方法，线程池会提前创建并启动所有核心线程来等待任务。




• maximumPoolSize：线程池允许创建的最大线程数，如果任务队列满了并且线程数小于maximumPoolSize时，则线程池仍旧会创建新的线程来处理任务。




• keepAliveTime：非核心线程闲置的超时时间，超过这个事件则回收，如果任务很多，并且每个任务的执行事件很短，则可以调用keepAliveTime来提高线程的利用率。另外，如果设置allowCoreThreadTimeOut属性为true时，keepAliveTime也会应用到核心线程上。




• TimeUnit：keepAliveTime参数的时间单位，可选的单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、秒（SECONDS）、毫秒（MILLOSECONDS）等。




• BlockingQueue ：任务队列，如果当前线程数大于corePoolSize，则将任务添加到此任务队列中。该任务队列是BlockiingQueue类型，也就是阻塞队列。




• ThreadFactory：线程工厂。可以用线程工厂给每个创建出来的线程设置名字。一般情况下无须设置参数。




• RejectedExecutionHandler ：饱和策略，这是当任务队列中和线程池都满了时所采取的对应策略，默认是ABordPolicy，表示无法处理新任务，并抛出RejetctedExecutionException异常。此外还有3种策略，它们分别如下：

（1）CallerRunsPolicy：用调用者所在的线程来处理任务，此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。

（2）DiscardPolicy：不能执行的任务，并将该任务删除。

（3）DiscardOldestPolicy：丢弃队列最近的任务，并执行当前的任务。

ThreadPoolExecutor的基本使用

package com.ju.executordemo;


import android.os.Bundle;

import android.support.v7.app.AppCompatActivity;

import android.util.Log;

import android.view.View;

import android.widget.Button;



import java.util.Random;

import java.util.concurrent.Executors;

import java.util.concurrent.LinkedBlockingDeque;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;



public class MainActivity extends AppCompatActivity{





    private Button btnStart;

    private final int CORE_POOL_SIZE = 4;//核心线程数

    private final int MAX_POOL_SIZE = 5;//最大线程数

    private final long KEEP_ALIVE_TIME = 10;//空闲线程超时时间

    private ThreadPoolExecutor executorPool;

    private int songIndex = 0;





    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        initView();

        //创建线程池

        initExec();

    }



    private void initView() {

        btnStart = findViewById(R.id.btn_start);

        btnStart.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                begin();

            }

        });

    }





    public void begin() {

        songIndex++;

        try {

            executorPool.execute(new WorkerThread("歌曲" + songIndex));

        } catch (Exception e) {

            Log.e("threadtest", "AbortPolicy...已超出规定的线程数量，不能再增加了....");

        }



        // 所有任务已经执行完毕，我们在监听一下相关数据

        new Thread(new Runnable() {

            @Override

            public void run() {

                try {

                    Thread.sleep(20 * 1000);

                } catch (Exception e) {



                }

                sout("monitor after");

            }

        }).start();



    }



    private void sout(String msg) {

        Log.i("threadtest", "monitor " + msg

                + " CorePoolSize:" + executorPool.getCorePoolSize()

                + " PoolSize:" + executorPool.getPoolSize()

                + " MaximumPoolSize:" + executorPool.getMaximumPoolSize()

                + " ActiveCount:" + executorPool.getActiveCount()

                + " TaskCount:" + executorPool.getTaskCount()

        );

    }







    private void initExec() {

        executorPool = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME, TimeUnit.SECONDS,

                new LinkedBlockingDeque(), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    }



    class WorkerThread implements Runnable {



        private String threadName;



        public WorkerThread (String name){

            threadName = name;

        }





        @Override

        public void run() {

            boolean flag = true;

            try {

                while (flag){

                    String tn  = Thread.currentThread().getName();

                    //模拟耗时操作

                    Random random = new Random();

                    long time = (random.nextInt(5) + 1) * 1000;

                    Thread.sleep(time);

                    Log.e("threadtest","线程\"" + tn + "\"耗时了(" + time / 1000 + "秒)下载了第<" + threadName + ">");

                    //下载完毕跳出循环

                    flag = false;

                }

            }catch (Exception e){

                e.printStackTrace();

            }

        }

    }



}