OC基础

Oc基础

1、#import的用途

1>#import与#include一样，拷贝文件的内容

2>可以自动防止文件的内容被重复拷贝

2、#import

        NSLog(<#NSString * _Nonnull format,…#>)声明的函数

3、Foundation框架头文件路径

1>、Xcode右击，显示报内容

2>、/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks

4、主头文件

1>、最主要的头文件，名字一般跟框架名一样，包含框架中所有的其他文件

2>、Foundation框架的主头文件名称就是Foundation.h

3>、只要包含了Foundation的主头文件，就可以使用整个框架的东西

5、运行过程

1>编写代码  .m .c

2>编译  xxx.m xxx.c

3>链接  xxx.o xxx.o

4>运行    ./a.out

6、在使用类的时候，会将类加载到内存中

没有对象内部都有一个isa指针，这个指针指向类的方法列表

7、方法与函数的区别

方法：

1>对象方法以-号开头

2>方法的声明必须写在@interface和@end之间

       方法的实现必须写在@implementation和end之间

3>对象方法只能又对象来调用

4>对象方法归对象和类拥有

函数：

1>函数可以写在文件的任意位置，函数归文件所有

2>函数的调用不依赖于对象

8、匿名对象

就是创建对象的时候，没有指针去指向这个对象

9、类方法和对象方法可以同名

类方法的执行效率比较高，但是类方法不能访问成员变量

10、工具类：基本没有任何成员变量的时候，里面的方法都是类方法。

11、继承

1>子类不能拥有和父类相同的成员变量

2>父类必须声明在子类之前

3>调用某个对象的方法，优先从该对象中查找，如果找不到再去父类中查找方法的实现

每个类中都有一个superClass指针，指向自己的父类，进而才可以去

super关键字的使用

1>super直接调用父类的方法

2>具体调用super的对象方法还是类方法，完全取决于当前的环境

3>子类中想先调用父类的方法之后，才去调用子类的方法时候，可以调用下super的方法

12、多态：父类的指针指向子类的对象 （狗 是DOG类型 ，它的父类是animation。所以一个狗的对象既可以用狗类的对象指针指向，也可以用动物类对象的指针指向）

1>没有继承就没有多态

2>如果函数的参数是父类，那么参数对象可以传子类、父类对象

3>局限性：父类类型的变量不能直接调用子类类型特有的方法

13、成员变量的作用域

局部变量、全局变量有自己的作用域，成员变量也不例外。

成员变量的作用域：

@public:在任何地方都能访问对象的成员变量             

@private:只有当前类的对象方法中访问    或者是用set/get方法 （@implementation中声明的成员变量默认是private）

@protected:可以在当前类以及子类的对象中直接访问（默认就是@protected）或者是用set/get方法

@package:只要处于同一框架，就可以直接访问对象的成员变量

在@implementation中也能定义一个成员属性，但是默认是私有的

@interface和@implementation不能声明同名的成员属性

14、@property  int age;会自动生成setAge和age方法的声明

@synthesizeage = _age;会自动声明setAge和age方法的实现，而且这句话会访问_age这个属性，如果不存在就会自动帮我们创建一个@private的_age属性。

@synthesizeage（如果不写=_age）会自动声明setAge和age方法的实现，而且这句话会访问_age这个属性，如果不存在就会自动帮我们创建一个@private的age属性。

Xcode4.3之后@property  int age这一句代码就会帮我们生成 _age 以及setAge、age的方法声明与实现，但是这个方法生成的成员属性是私有的，不能让子类进行访问，如果想让子类进行访问，那么就需要在.h中声明声明一个protected的_age属性

如果手动实现了set方法，那么编译器就只会生成get方法和下划线属性

如果手动实现了get方法，那么编译器就只会生成set方法和下划线属性

如果手动生成了set和get方法，那么编译器就不会帮你生成下划线属性

15、构造方法

用来初始化对象的方法，是一个对象方法

重写init方法：

1>调用【super init】方法初始化父类的属性，并赋值给self

2>判断self是否为空，不为空则进行初始化属性操作

3>返回self

重写构造方法的目的：为了创建对象的时候，成员变量就有值

-(instancetype)init{

    if(self=[superinit]){

        _age  =10;

    }

    returnself;

}

自定义构造方法：

1>一定是对象方法，以 - 开头

2>返回类型是 id类型

3>方法名以initWith开头

-(instancetype)initWithAge:(int)age{

    if(self=[superinit]){

        _age = age;

    }

    returnself;

}

16、修改Xcode创建文件的时候的一些配置属性

/Applications/Xcode.app/Contents/Developer/Library/Xcode/Templates在这里面修改

17、分类：可以给某一类扩展一些方法,在不改变原来类的基础上，为类增加一写方法。

分类的使用注意：

1>只能增加方法，不能只能成员变量

2>分类方法的实现中可以访问原来类的成员变量

3>分类可以重新实现原来类中的方法，但是会覆盖掉原来类中的方法，会导致原来类中的方法无法使用

4>方法调用的优先级： 分类（最后编译的分类优先） —> 原类 —> 父类

18、

1>当程序启动时，就会加载项目中所有的类和分类，而且加载后会调用类和分类的+ (void)load{   

}方法，只会调用一次

2>当第一次使用某个类的时候，会调用当前类的+(void)initialize

}方法

3>先加载父类，再加载子类，最后加载分类的（先调用父类的load方法，再调用子类的load方法）

先初始化父类，再初始化子类（先调用父类的initialize方法，再调用子类的initialize方法）

19、类也是个对象

类也是一个对象，是一个class类型的对象，简称类对象

Class类型的定义

typedefstructobjc_class * Class

类名就代表类对象，每个类只有一个对象

20、-(NSString *)description{}方法

默认情况下，利用NSLog和%@输出对象的时候，结果是<类名：内存地址>

1>会调用对象的description方法

2>拿到description方法的返回值展示到屏幕上

3>description默认返回的是“类名+内存地址”

+(NSString *)description{}方法,类的-(NSString *)description{}方法，默认返回的是类名

21、    NSLog(@"%s",__FILE__);

NSLog输出c语言字符串的时候，不可以包含中文

22、SEL

typedefstructobjc_selectorSEL

SEL s = NSSelectorFromString(@"test")

NSStringFromSelector(@selector(test))

_cmd代表当前方法

 NSString *s = NSStringFromSelector(_cmd);

SEL其实是对方法的一个包装，去找到对应的方法地址就可以调用此方法

内存管理   

1、局部变量的对象是放在栈中的，系统会管理他们的内存

     一个oc对象的内存是放在堆中的，需要我们去手动管理他的内存

2、每个对象的内部都有四个字节来存储对象的内存空间

当一个对象alloc /new /copy的时候引用计数器会+1

给对象发送 retain 消息的时候，对象的引用计数器+1

        给对象发送release消息的时候，对象的引用计数器-1

        给对象发送 retainCount 消息的时候，返回对象的引用计数器的个数

3、对象销毁

       当一个对象的引用计数器为0的时候，系统会给对象发送一个dealloc消息，一般重写此方法在其中做一些释放性的操作

4、野指针： 指针指向了一块已经释放的内存对象（这个对象成为僵尸对象）给野指针发送消息会报错 野指针经常报错为 EXC_BAD_ADRESS

      空指针：没有指向任何对象的指针（存储的为nil/NULL/0） oc中给nil 发送消息不会报错

      僵尸对象：所占用的内存已经被回收的对象，僵尸对象不能再继续使用

5、retain方法会返回对象本身

      release方法不会有返回值

6、delloc

      当对象要被回收的时候会调用、一定要调用【super delloc】，因为【super delloc】中也要做一些释放操作，而且这一句一定要写在最后

7、alloc/new/mutableCopy来创建对象的时候，引用计数器会+1，不使用这个对象的时候，需要将引用计数器-1

8、谁retain了，谁就要release

9、当你想使用或者占有某个对象的时候，需要对对象进行一次retain操作

      当你不想使用或者占有某个对象的时候，需要对对象进行一个release操作

      谁retain谁release

      谁alloc谁release

10、假如person  有一个car属性

_car：直接访问成员属性

self->_car：直接访问成员属性

self.car  ：get方法

[self car]：get方法

11、MRC中的set方法 

@interfacePerson : NSObject

{

    Car *_car;

}

-(void)setCar:(Car *)car;

-(Car *)car;

@end

@implementationPerson

-(void)setCar:(Car *)car{

    if(_car != car){        //这个判断是为了防止调用多次[self car]此时的car为同一个car，先给_car做一次release操作，此时car已经被释放了，然后再去调用【car retain】方法，这个相当于是给一个僵尸对象发送了一个retain消息。

        [_car release];    //这个是为了防止在你给对象赋值新的car的时候，原有的car没有做release操作，而导致的原有的car不会被释放

        _car =[car retain];//这段代码是为了谁拥有谁就要去retain

    }

}

-(Car *)car{

    return_car;

}

@end

12、内存管理的原则

1>只要调用了alloc，就必须调用release或者autorelease

2>set方法的代码规范

   基本数据类型:

-（void）setAge:(int)age{

_age = age;  直接赋值

}

    对象类型：

-(void)setCar:(Car*)car{

if(_car != car){

[_car release];//对旧对象进行release操作

_car =[car retain];//对新对象进行retain操作

}

}

3>delloc //对self所拥有的所有对象进行一次release操作

-(void)delloc{

[_car  release];

//最后调用【super delloc】

[super delloc];

}

13、property默认生成的set和get方法是直接赋值assign

14、property(retain)就是相当于在set方法中先release旧值，再retain新值

15、property的参数有四个

1>set方法内存管理的相关参数

*retain：先release旧值，再retain新值

*assign：直接赋值

*copy

2>多线程管理

nonatomic :（性能高,set方法的时候不加线程锁）

atomic :（性能低，加线程锁）

3>是否只生成set和get方法

*readwrite：同时生成set和get方法的声明与实现

*readolny:只生成get的声明与实现

4>set和get的方法名称

setter：决定了set：的方法名，一般是需要带冒号的

getter:决定了getter方法名（一般用在bool类型）

例如：

@property(nonatomic,retain,readwrite,setter=setCarrrrr:,getter=carrrrr)Car *car;

16、

定义一个枚举

typedefenum{

    SexMan,

    SexWoman

} Sex;

定义一个结构体

typedefstruct{

    intyear;

    intmonth;

    intday;

} Date;

17、@class只是告诉对象 这是一个类 ， 但是不包含.h中的属性与方法

 1>@class只是告诉编译器某个名称是一个类，例如@class person仅仅告诉编译器person是一个类

2>开发中引用一个类的规范

在.h中用@class来声明

在.m中用import来包含类的声明

3>两端循环引用的解决方案

一端用retain一端用assign

在.h中用@class来声明可以解决循环包含的错误 

例如

#import <Foundation/Foundation.h>

#import "Person.h"

@interfaceCar : NSObject

@property(nonatomic,retain)Person *p;

@end

#import <Foundation/Foundation.h>

#import "Car.h"

@interfacePerson : NSObject

@property(nonatomic,retain)Car *car;

@end

这样会报错，编译不通过

#import <Foundation/Foundation.h>

@classPerson;

@interfaceCar : NSObject

@property(nonatomic,retain)Person *p;

@end

#import <Foundation/Foundation.h>

@classCar;

@interfacePerson : NSObject

@property(nonatomic,retain)Car *car;

@end

这样才不会报错，编译可以通过，然后在.m文件中用#import “”来包含头文件

这样做编译效率也比较高，如果按照第一种方式，一旦包含的类种的属性或者方法修改过了，就会造成每一个只要#import “”的.h都会重新编译一遍，造成效率比较低

18、autorelease的使用

autorelease方法会返回对象本身

autorelease 会把对象放在一个自动释放池中，当自动释放池被销毁的时候，会对池中的对象做一次release操作

    @autoreleasepool{

        Person *p =  [[[Person alloc]init]autorelease];

    }

会在池子结束的时候，对person对象调用一次release操作

autoreleasepool是可以嵌套使用的，而且autoreleasepool是放在栈内存中的，先进后出。

autoreleasepool的基本用法：

1>会将对象放入一个自动释放池中

2>当自动释放池销毁的时候，会对池中的对象进行一次release操作

3>会返回对象本身

4>调用完autorelease方法，对象的引用计数器不变，只有当autoreleasepool执行完毕之后，才会对池中的所有对象进行一次release操作

autorelease的好用：

1>不用关心对象释放的时间

2>不用关心什么调用对象的release

autorelease的使用注意：

1>占用较大内存的对象，不要随便的使用autorelease

2>占用较小内存的对象使用autorelease没有太大的影响

池子autoreleasepool的错误写法：

1>    @autoreleasepool{

        Person *p =  [[[[Person alloc]init]autorelease]autorelease];//调用两次autorelease会出现野指针错误

    }

2>    @autoreleasepool{

        Person *p =  [[[Person alloc]init]autorelease];

        [p release];

    }        也会出现也指针错误

3>        Person *p =  [[[Person alloc]init]autorelease];这样写没有任何的意义，因为autorelease不放到autoreleasepool中是不会调用release的

自动释放池：

1>ios程序中也会创建自动释放池，这些自动释放池以栈的形式存在

2>当一个对象调用autorelease方法的时候，会将这个对象放到栈顶的释放池

自动释放池的创建方法：

#pragma mark ios5之前

    NSAutoreleasePool *pool =[[NSAutoreleasePool alloc]init];

    Person *p =  [[[Person alloc]init]autorelease];

    [pool release];

#pragma mark ios5之后

    @autoreleasepool{

        Person *p =  [[[Person alloc]init]autorelease];

        [p release];

    }

}

19、

1>系统自带的方法没有alloc/new/copy,说明返回的对象都是autorelease的

例如  NSString *str =[NSString stringWithFormat:@"string"];

    NSString *str1 =[NSString stringWithString:@"string"];

2>开发中经常提供一些类方法快速创建一个已经autorelease的对象

创建对象的时候，不要直接用类名，要用self，以满足子类的需求

例如

+(id)person{

    return  [[[selfalloc]init]autorelease];

}

内存管理的总结：

一、计数器操作：

1>retain +1；

2>release -1;

3>retaincount  :获取计数器

二、set方法的内存管理

1>set的实现

-(void)setCar:(Car *)car{

    if(_car != car){

        [_car release];

        _car =[car retain];

    }

}

2>delloc方法的实现（不要直接调用delloc）

-(void)dealloc{

    [_car dealloc];

    [superdealloc];

}

三、property参数

oc对象：

@property(nonatomic,retain)类名*属性名;

非oc对象：

@property(nonatomic,assign)类型名称属性名；

四、@autoreleasepool

1、系统的方法中如果不带有alloc、new、copy,这些方法返回的对象都是已经autorelease过的

2、在开发过程中用类方法创建对象的时候，不要直接使用类名。可以用self（利用类方法快速创建一个autorelease对象）

ARC

ARC的判断准则：只要没有强指针指向对象，就会释放对象

1>ARC的特点是不允许调用retain/release/retainCount

2>允许重写delloc,但是不允许调用【super delloc】

3>property参数

*strong 成员变量是强指针 ，相当于之前retain（只适用于oc对象）

*weak成员变量是弱指针，相当于之前的assign(适用于oc对象)

*assign：适用于非oc对象

指针分为两种：

强指针：__strong 默认情况下就是强指针

弱指针：__weak  当弱指针指向的对象消失后，默认会指向nil

ARC与MRC的转换

1>mrc项目 转 arc

xcode -> edit ->convert -> to object ARC

2>查看项目当前是否为 ARC

buildSetting ->搜索auto -> objectc automatic reference counting ->yes代表arc No代表mrc

3>将项目中某个文件改为 arc或者mrc

build phases ->compile source ->-fno-objc-arc不需要arc或者-f-objc-arc需要ARC

当两端循环引用的时候，解决的方案

1、ARC

一端用strong一端用weak

2、非arc

一端用retain一端用assign

Block:

intsum(inta,intb){

    returna+b;

}

-(void)viewDidLoad {

    [superviewDidLoad];

    int(*p)(int,int)= sum;

    intsum = p(10,12);

    NSLog(@"%d",sum);

}

指向函数的指针

int(^sumBlock)(int,int)=^(inta,intb){

        returna+b;

    };

    sumBlock(100,100);

1>如何定义block变量

Int(^SumBlock)(int,int);

void(^myBlock)();

2>如何利用block封装代码块

^(int a,int b){

return a-b

};

^(){

NSLog(@“111111”);

};

3>block访问外部变量

*block内部可以访问外面的变量

*默认情况下，block内部不能修改外面的变量

*给局部变量上加上__block关键字，这个局部变量才可以在block内部修改

4>利用typedef定义block类型

typedefint(^MyBlock)(int,int);

以后就可以利用MyBlock这种类型来定义block变量

协议Protocol

1>基本用途

*可以用来声明一大堆方法

*只要某各类遵守了这个协议，就相当于拥有了这个协议的所有方法

*只要父类遵守了某个协议，就相当于子类也遵守了

2>格式

@protocol协议名称

//协议方法

@end

某个类遵守某个协议

@interface类名：父类<协议名称1，协议名称2>

@end

3>关键字

@required:这个方法是必须实现的（若不实现，编译器会发出警告）

@optional这个方法不一定实现

4>协议遵守协议

*一个协议可以遵守其他多个协议，多个协议之间用逗号隔开

*一个协议遵守了其他协议，就相当于拥有了其他以协议中的方法声明

@protocol协议名称<协议1，协议2>

@end

5>基协议

*nsobject是一个基类，最根本最基础的类，热河其他类都要继承它

*其实还有一个协议，名字也叫NSobject，它是一个基协议，最根本的协议

*nsobject协议中声明很多最基本的方法，比如description、retain、release等

*建议每一个新协议都要遵守nsobject协议

6>定义一个变量的时候，限制这个变量保存的对象遵守某个协议

类名<协议名称>*变量名；

id<协议名称>变量名；

NSObject*object；

Idobj2;

如果没有遵守协议，编译器会报警

7>@propety中声明的属性也可以用作一个遵守协议的限制

@property(nonatoimic，strong)类名<协议名称>*属性名

8>协议可以定义在单独的.h中，也可以定义在某个类型中

*如果这个协议只用在某个类中，应该定义在该类中

*如果某个协议用在很多类中，就应该把协议定义在单独的文件中

9>分类可以定义在单独.h和.m文件中，也可以定义在原类中

1>一般情况下，都是定义在单独文件

2>定义在原类中的分类，只要求看懂语法

集合中的对象的内存管理

1>当对象被添加到集合中的时候，对象的引用计数器会加一

2>当集合被销毁的时候，会对集合中的对象发送一次release消息

3>当对象被移除的时候，也会给对象发送一次release消息

@property内存管理的策略

1非ARC

1>copy：只用于nsstring/block

2>retain：除nsstring/block以外的oc对象

3>assign：基本数据类型、枚举、结构体（非oc对象）当两个对象相互引用的时候，一端用retain一端用assign

2ARC

1>copy：只用于nsstring/block

2>strong：除nsstring/block以外的oc对象

3>assign：基本数据类型、枚举、结构体（非oc对象）

4>weak当两个对象相互引用的时候，一端用retain一端用assign

自定义类实现copy操作

1>类遵守NSCopying协议

2>实现-(id)copyWithZone:(nullableNSZone *)zone;方法

3>在- (id)copyWithZone:(nullableNSZone *)zone方法中创建一个新的对象，并设置该对象数据与现有对象一致，并返回该对象

单例模式

alloc方法其实调用的是allocWithZone

Static修饰局部变量，只创建一次

static修饰的全局变量，只有当前文件才可以访问，并且只创建一次

1>永远只分配一块内存来创建对象

2>提供一个类方法，返回内部唯一的一个对象

3>最好保证init方法也只初始化一次

Dispath_once方法是线程枷锁的，能保证线程安全

非ARC单例模式的实现比ARC单例模式的实现多了

-(id)retain{

}

-(NSUInteger)retainCount{

}

-(onewayvoid)release{

}

-(instancetype)autorelease{

}

// ## : 连接字符串和参数

#if __has_feature(objc_arc)判断编译环境是ARC还是MRC

#define singleton_h(name)+(instancetype)shared##name;

#if __has_feature(objc_arc)// ARC 

#define singleton_m(name)\

static id _instance;\

+(id)allocWithZone:(struct _NSZone *)zone \

{ \

    static dispatch_once_t onceToken;\

    dispatch_once(&onceToken,^{ \ dispatch_once线程安全，枷锁了

        _instance =[super allocWithZone:zone];\

    });\

    return _instance;\

} \

 \

+(instancetype)shared##name \

{ \

    static dispatch_once_t onceToken;\

    dispatch_once(&onceToken,^{ \

        _instance =[[self alloc]init];\

    });\

    return _instance;\

} \

+(id)copyWithZone:(struct _NSZone *)zone \

{ \

    return _instance;\

}

#else// 非ARC

#define singleton_m(name)\

static id _instance;\

+(id)allocWithZone:(struct _NSZone *)zone \

{ \

static dispatch_once_t onceToken;\

dispatch_once(&onceToken,^{ \

_instance =[super allocWithZone:zone];\

});\

return _instance;\

} \

\

+(instancetype)shared##name \

{ \

static dispatch_once_t onceToken;\

dispatch_once(&onceToken,^{ \

_instance =[[self alloc]init];\

});\

return _instance;\

} \

\

-(oneway void)release \

{ \

\

} \

\

-(id)autorelease \

{ \

return _instance;\

} \

\

-(id)retain \

{ \

return _instance;\

} \

\

-(NSUInteger)retainCount \

{ \

return 1;\

} \

\

+(id)copyWithZone:(struct _NSZone *)zone \

{ \

return _instance;\

}

#endif

控制器的生命周期

-(void)loadView{

    [superloadView];

}

-(void)viewDidLoad{

    [superviewDidLoad];

}

-(void)viewWillAppear:(BOOL)animated{

    [superviewWillAppear:animated];

}

-(void)viewDidAppear:(BOOL)animated{

    [superviewDidAppear:animated];

}

-(void)viewWillDisappear:(BOOL)animated{

    [superviewWillDisappear:animated];

}

-(void)viewDidDisappear:(BOOL)animated{

    [superviewDidDisappear:animated];

}

-(void)viewWillUnload{

    [superviewWillUnload];

}

销毁view

-(void)viewDidUnload{

    [superviewDidUnload];

}

-(void)didReceiveMemoryWarning{

    [superdidReceiveMemoryWarning];

}

Block可以使用在定义之前声明的局部变量

    inti=10;

    void(^myBlock)(void)= ^(){

        NSLog(@"%d",i);

    };

    i = 100;

    myBlock();

打印的结果是 10；

1>在定义block的时候，会在block中建立当前局部变量的内容的副本（拷贝）

2>后续对该值进行修改不会影响block中的数值

3>如果需要在block中保持局部变量的数值变化，需要使用————block关键字

4>使用————block关键字之后，同样可以在block中修改变量的值

runtime

运行时机制：比较高级的特性，纯C语言

平时的oc代码——>C语言的运行时代码

默认情况下任何block的内存都是分配在栈中的，随时可能被回收。

对block进行一次copy操作就会把内存分配到堆中。

block会对代码块中的对象进行一次强引用，例如

self.block = ^{

self.age = 20;

}

这个时候，block会对self进行一次强引用，而block又是self的一个copy属性，也属于强引用，所以造成了循环引用；

因此当block中使用了对象的时候，需要判断是否造成了循环引用。如果造成了循环引用，就需要用——weak 来重新用指针指向对象

或者__unsafe_unretained  来重新修饰 

例如

__unsafe_unretainedPerson *p2 = p1;

    __weakPerson *p3 = p1;

    __weaktypeof(self)weakSelf =self;

    typeof(self) 就是用来判断类型，即等价于 self的类型*

KVC

利用kvc可以随意的修改一个对象的属性或者成员变量（并且私有的也可以）

Person *p1 =[[Person alloc]init];

    Dog *dog =[[Dog alloc]init];

    [p1.dog setValue:@"dogname" forKey:@"name"];

    [p1.dog setValue:@"dogname" forKeyPath:@"dog.name"];

人对象有一个狗的属性，狗又有name的属性；

    [p1.dog setValue:@"dogname" forKey:@"name”];中的key只能是属性名，否则会报错；

    [p1.dog setValue:@"dogname" forKeyPath:@"dog.name"];

可以是路径，又可以是属性名

forKeyPath包含了for的功能，以后用forkeyPath

iOS中的多线程

1>一个NSTread对象就代表一条线程

2>创建和启动线程

NSThread *thread =[[NSThread alloc]initWithTarget:selfselector:@selector(run:)object:@"hah"];

  [thread start];

3>主线程相关的用法

[NSThread mainThread];

[NSThread isMainThread];

 [thread isMainThread];

4>设置线程的优先级

    [NSThread threadPriority];查看当前线程的优先级

    [NSThread setThreadPriority:0.5];设置当前线程的优先级

5>设置线程的名字

    thread.name = @"线程一";

6>创建线程的时候就启动线程

 [NSThread detachNewThreadWithBlock:^{

    }];

    [NSThread detachNewThreadSelector:@selector(run:)toTarget:selfwithObject:@"哈哈"];

7>隐shi创建

    [selfperformSelectorInBackground:@selector(run:)withObject:@"哈哈”];

线程的状态

当线程在阻塞和死亡状态的时候，会退出可调度线程池中。但是内存还在。

线程状态的控制

最后的参数是说这个performSelector方法是否等待执行完毕，才继续跳出子线程操作

GCD

会自动帮我们创建线程

MRC中队列是需要释放的  当调用creat方法的时候，要调用dispatch_release(queue)方法去释放队列

在ios中凡是函数带有create、copy/new/retain等字眼，都需要在不需要使用这个数据的时候调用release操作

 CFArrayRef array = CFArrayCreate(0,0,11,0);

    CFRelease(array);在调用CF函数的时候，即使是在arc环境下也需要调用一下release操作

CF(core Facation)框架在ARC中也需要手动release

同步函数：

*串行队列：不开启新的线程，任务串行执行

*串行队列（主队列）会出现死锁

*并行队列：不开启新线程，任务串行执行

异步函数：

*串行队列 ：开启一条新的线程，任务并行执行

*串行队列（主队列）不会开启新的线程

*并行队列： 开启新的线程，任务并行执行

    dispatch_queue_t mainqueue = dispatch_get_main_queue();

    dispatch_sync(mainqueue,^{

        NSLog(@"这样会死锁");

    });

dispatch_queue_t mainqueue = dispatch_get_main_queue();

    dispatch_async(mainqueue,^{

        NSLog(@"这样不会发生死锁");

    });

因为异步函数虽然也是放在了主线程中，但是比较特殊，会将block中的代码缓后执行，所以不会出现死锁

延迟执行：

第一GCD：

 //全局并发队列

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

    //计算执行任务的时间

    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW,(int64_t)(3.0 * NSEC_PER_SEC));

    //在when的这个时间点去执行queue的任务

    dispatch_after(when,queue,^{

    });

第二：

    [selfperformSelector:@selector(run:)withObject:@"hahha" afterDelay:3.0];

一次性代码

 staticdispatch_once_t onceToken;

    dispatch_once(&onceToken,^{

    });

#define global_queue dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)

#define main_queue dispatch_get_main_queue()

 dispatch_group_t group = dispatch_group_create();

    dispatch_group_async(group,global_queue,^{

        //下载图片1

    });

    dispatch_group_async(group,global_queue,^{

        //下载图片2

    });

    dispatch_group_notify(group,main_queue,^{

        //当任务一 与 任务二 完成之后，回到主线程中去操作

    });

NSOpertion：

多线程

1.NSThread

1> 开线程的几种方式

* 先创建,后启动

NSThread *thread =[[NSThread alloc]initWithTarget:selfselector:@selector(run)object:nil];

[thread start];

* 直接启动

[NSThread detachNewThreadSelector:@selector(run)toTarget:selfwithObject:nil];

[selfperformSelectorInBackground:@selector(run)withObject:nil];

2> 其他用法

NSThread *current =[NSThread currentThread];

+(NSThread *)mainThread;// 获得主线程

3> 线程间通信

performSelectorOnMainThread.....

2.GCD(重点)

1> 队列的类型

* 并发队列

获得全局的并发队列: dispatch_get_global_queue

* 串行队列

a.自己创建

dispatch_queue_create

b.主队列

dispatch_get_main_queue

2> 执行任务的方法类型

*同步(sync)执行

*异步(async)执行

3> 了解队列和方法的配合使用

4> 线程间通信

dispatch_async(

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),^{

   // 执行耗时的异步操作...

   dispatch_async(dispatch_get_main_queue(),^{

       // 回到主线程，执行UI刷新操作

   });

});

5> 其他用法

dispatch_once

dispatch_after

dispatch_group_async\dispatch_group_notify

3.NSOperation

1> 基本使用

NSInvocationOperation

NSBlockOperation

2> NSOperationQueue(重点)

* 最大并发数设置

-(void)setMaxConcurrentOperationCount:(NSInteger)cnt;

* 设置依赖(面试题)

[operationB addDependency:operationA];// 操作B依赖于操作A

3>自定义Operation(了解基本流程)

4> 如何解决一张图片(一个url)重复下载的问题(面试题)