黑马程序员——OC—内存管理

wu417284911

于 2015-03-28 12:27:22 发布

阅读量391

点赞数

分类专栏： OC

本文链接：https://blog.csdn.net/wu417284911/article/details/44700317

版权

OC 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

OC—内存管理

一、内存的概念：

当app所占内存较多时，会回收一些不使用的对象，变量。基础数据类型存放在内存栈中，系统会自动回收，OC对象存放在内存堆中，系统不会自动回收，这就要求我们手动释放内存。

二、引用计数器：

1. 本质：引用计数器存在对象内存中，占用4个字节。

2. 作用：用来表示对象当前被以用的次数。

3. 特点：

1). 当使用 alloc 或 new 或 copy 创建对象时，新对象的引用计数器为1

2). 当对象引用计数器为0，系统会自动回收。

4. 引用计数器的使用：

1). 给对象发送一条retain消息，引用计数器 +1

2). 给对象发送一条release消息，引用计数器 -1

3). 给对象发送一条retainCount消息，获取当前计数器的值

5. dealloc方法：

1). 当一个对象引用计数器为0，对象被销毁，内存被回收

2). 当一个对象被销毁时，系统会自动向对象发一条dealloc消息

3). 重写dealloc方法，在这里释放相关的资源，dealloc就像对象的遗言

4). 只要重写了dealloc方法，就必须调用 [super dealloc] 并且放在最后面调用

5). 不要直接调用dealloc方法

6). 一旦对象被回收，它所占有的内存就不再可用，坚持使用会导致程序崩溃

代码示例：

Person 类：

#import <Foundation/Foundation.h>

@interface Person : NSObject

@property int age;

@end

#import "Person.h"

@implementation Person

// 当一个Person对象被回收的时候，就会自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");

    // super的dealloc一定要调用，而且放在最后面
    [super dealloc];
}

@end

main 函数：

#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{
    // 1
    Person *p = [[Person alloc] init];

    //NSUInteger c = [p retainCount];

    //NSLog(@"计数器：%ld", c);


    // 2 retain方法返回的是对象本身
    [p retain];

    // 1
    [p release];

    // 0 野指针：指向僵尸对象（不可用内存）的指针
    [p release];

    [p retain];

    // -[Person setAge:]: message sent to deallocated instance 0x100109a10
    // 给已经释放的对象发送了一条-setAge:消息：
    p.age = 10;
    //[p setAge:10];

    // 指针p变成空指针
    //p = nil;

    // EXC_BAD_ACCESS : 访问了一块坏的内存（已经被回收、已经不可用的内存
    // 野指针错误
    // OC不存在空指针错误，给空指针发送消息，不报错
    [p release];
    [p release];
    [p release];
    [p release];

    [nil release];

    return 0;
}

代码分析：创建Person对象用到alloc，有alloc就要有release，防止内存泄露，只要引用计数器为0，内存就会被回收，这时对象不可用，继续强用，发生野指针错误。

6. 僵尸对象、野指针：

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

野指针：指向僵尸对象（不可用内存）的指针。

空指针：没有指向任何东西的指针，空指针发送消息不会出错。

7. 规范小结：

1).你想使用（占用）某个对象，就应该让对象的计数器 +1（让对象做一次retain操作）

2).你不向再使用（占用）某个对象，就应该让对象的计数器 -1（让对象做一次release操作）

3).谁alloc，谁release

4).谁retain，谁release

8. alloc和release的进阶

1). 成员变量是基本数据类型，直接赋值

2). 成员变量是OC对象，考虑引用对象的retain和release操作。

代码示例：

Car 类：

#import <Foundation/Foundation.h>

@interface Car : NSObject
{
int _speed;
}

- (void)setSpeed:(int)speed;
- (int)speed;
@end

#import "Car.h"

@implementation Car
- (void)setSpeed:(int)speed
{
_speed = speed;
}
- (int)speed
{
return _speed;
}

- (void)dealloc
{

    NSLog(@"速度为%d的Car对象被回收了", _speed);

    [super dealloc];
}

@end

Person 类：

#import <Foundation/Foundation.h>
#import "Car.h"

@interface Person : NSObject
{
Car *_car;
int _age;
}

- (void)setAge:(int)age;
- (int)age;

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

@end

#import "Person.h"

// _car -> c1 0

@implementation Person
- (void)setCar:(Car *)car
{
    if (car != _car)
    {
        // 对当前正在使用的车（旧车）做一次release
        [_car release];

        // 对新车做一次retain操作
        _car = [car retain];
    }
}
- (Car *)car
{
    return _car;
}

- (void)setAge:(int)age
{ // 基本数据类型不需要管理内存
_age = age;
}
- (int)age
{
return _age;
}

- (void)dealloc
{
    // 当人不在了，代表不用车了
    // 对车做一次release操作
    [_car release];

    NSLog(@"%d岁的Person对象被回收了", _age);

    [super dealloc];
}

@end

main 函数：

#import <Foundation/Foundation.h>
#import "Car.h"
#import "Person.h"

int main()
{
     // p-1
    Person *p = [[Person alloc] init];
    p.age = 20;

    // c1-1
    Car *c1 = [[Car alloc] init];
    c1.speed = 250;

    // p想拥有c1
    // c1-2
    p.car = c1; // [p setCar:c1];

    // c2-1
    Car *c2 = [[Car alloc] init];
    c2.speed = 300;

    // p将车换成了c2
    // c1-1
    // c2-2
    p.car = c2;

    // c2-1
    [c2 release];
    // c1-0
    [c1 release];
    // p-0 c2-0
    [p release];

    return 0;
}

void test2()
{
    Person *p1 = [[Person alloc] init];
    p1.age = 20;

    // c1 - 1
    Car *c1 = [[Car alloc] init];
    c1.speed = 100;
    // c1 - 2
    p1.car = c1;
    // c1 - 1
    [c1 release];

    Car *c2 = [[Car alloc] init];
    c2.speed = 200;
    // c1 - 0
    p1.car = c2;

    [c2 release];

    [p1 release];
}

void test1()
{
    // p-1
    Person *p = [[Person alloc] init];
    p.age = 20;

    // c1-1
    Car *c1 = [[Car alloc] init];
    c1.speed = 250;

    // c1-2
    p.car = c1;

    // c1-1
    [c1 release];

    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;


    [p release];
}

9. 内存管理代码规范：

1.只要调用了alloc，必须有release（autorelease）对象不是通过alloc产生的，就不需要release

2.set方法的代码规范
1> 基本数据类型：直接复制
- (void)setAge:(int)age
{
    _age = age;
}

2> OC对象类型
- (void)setCar:(Car *)car
{
    // 1.先判断是不是新传进来对象
    if ( car != _car )
    {
        // 2.对旧对象做一次release
        [_car release];

        // 3.对新对象做一次retain
        _car = [car retain];
    }
}

3.dealloc方法的代码规范
1> 一定要[super dealloc]，而且放到最后面
2> 对self（当前）所拥有的其他对象做一次release
- (void)dealloc
{
    [_car release];
    [super dealloc];

三、 @ property管理内存：

1. 作用：自动生成setter方法中retain和release操作

2. @ property四种参数

         1. set方法参数
           1). retain : release旧值，retain新值（适用于OC对象类型）
            2).   assign : 直接赋值（默认，适用于非OC对象类型）
            3).copy   : release旧值，copy新值

         2.是否要生成set方法
            1).readwrite : 同时生成setter和getter的声明、实现(默认)
            2).readonly : 只会生成getter的声明、实现

         3.多线程管理
            1). nonatomic : 性能高 (一般就用这个)
            2). atomic    : 性能低（默认）

         4.setter和getter方法的名称
            1). setter : 决定了set方法的名称，一定要有个冒号 :
            2). getter : 决定了get方法的名称(一般用在BOOL类型)

代码示例：

Person 类：

@property (nonatomic, assign, readwrite) int weight;
// setWeight:
// weight

//
@property (readwrite, assign) int height;

@property (nonatomic, assign) int age;

@property (retain) NSString *name;
@end

@implementation Person

@end

main 函数：

#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{
    Person *p = [[Person alloc] init];


    p.rich = YES;

    BOOL b = p.isRich;

    return 0;
}

代码分析：@ property参数retain会自动帮我们生成set方法中retain和release 基本数据类型用assign 一般就用到retain、assign、nonatomic

四、循环引用：

1. 本质：循环引用就是你引用我，我引用你，但是双方都不可以释放内存。

2. @class替换#import：

1).@class作用：声明一个类存在。

2). A类import B类，B类import A类，编译器不允许这么做。

         3). 开发中引用一个类的规范
            1. 在.h文件中用@class来声明类
             2. 在.m文件中用#import来包含类的所有东西

3. @class和#import区别：

@class 只是用来声明一个类的存在，不包括成员变量和方法。

#import 引用一个类的全部，类的声明、成员变量和方法。

4. 循环引用中，@property 参数中都用retain会导致两个对象都无法释放内存

代码示例：

Card 类：

#import <Foundation/Foundation.h>

@class Person;

@interface Card : NSObject

@property (nonatomic, assign) Person *person;

@end

#import "Person.h"

@implementation Card

- (void)dealloc
{
    NSLog(@"Car被销毁了");

    // [_person release];

    [super dealloc];
}

@end

Person 类：

#import <Foundation/Foundation.h>
#import "Card.h"
// @class仅仅是告诉编译器，Card是一个类
//@class Card;

@interface Person : NSObject

@property (nonatomic, retain) Card *card;

@end

#import "Person.h"
#import "Card.h"

@implementation Person

- (void)dealloc
{
    NSLog(@"Person被销毁了");
    [_card release];

    [super dealloc];
}

@end

#import <Foundation/Foundation.h>
#import "Card.h"
#import "Person.h"

int main()
{
    // p - 1
    Person *p = [[Person alloc] init];
    // c - 1
    Card *c = [[Card alloc] init];

    // c - 2
    p.card = c;

    // p - 1
    c.person = p;

    // c - 1
    [c release];

    // p - 0 c - 0
    [p release];
    return 0;
}

代码分析：对象双方如果都retain 会都retain 不符合规范，要保证人无车无。

5. 循环引用解决：

一端用retain 一端用assign

五、autorelease自动释放池

1. 基本用法：

1). 给对象发送一条autorelease消息，会把这个对象加到自动释放池中。

2). 当自动释放池销毁时，会对池子里的对象发送一条release消息。

3). 调用autorelease消息会返回对象本身

2. autorelease原理：

autorelease实际上是把release延迟了，对于每个对象的autorelease，将对象放到pool池中，当pool被销毁时，pool中所有对象会调用release

3. 使用规范：

若要用autorelease 就不能再用release 并且所有的代码写在@autoreleasepool{ }代码块中

代码示例：

Person 类：
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic, assign) int age;

@end

#import "Person.h"

@implementation Person
- (void)dealloc
{
    NSLog(@"Person---dealloc");

    [super dealloc];
}
@end

main 函数：

#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{

    @autoreleasepool
    {// { 开始代表创建了释放池

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

        p.age = 10;



        @autoreleasepool
        {
            // 1
            Person *p2 = [[[Person alloc] init] autorelease];
            p2.age = 10;


        }


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


    } // } 结束代表销毁释放池
}

4. autorelease的好处和坏处：
     1). 不用再关心对象释放的时间
     2). 不用再关心什么时候调用release
     3). 不能随时准确的释放内存，只有在pool被销毁时，对象才会被销毁。

5. autorelease使用注意：

1). 占用内存较大的对象不要随便使用autorelease
2). 占用内存较小的对象使用autorelease，没有太大影响

3). alloc之后调用了autorelease，不能再调用release

4). 不能连续调用多次autorelease

6. 自定义创建autorelease的对象：

代码示例：

GoodPerson 类：

#import "Person.h"

@interface GoodPerson : Person

@property (nonatomic, assign) int money;

@end

#import "GoodPerson.h"

@implementation GoodPerson

@end

Person 类：

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (nonatomic, assign) int age;

+ (id)person;

+ (id)personWithAge:(int)age;

@end

#import "Person.h"

@implementation Person

+ (id)person
{
return [[[self alloc] init] autorelease];
}

+ (id)personWithAge:(int)age
{
    Person *p = [self person];
    p.age = age;
    return p;
}

- (void)dealloc
{
    NSLog(@"%d岁的人被销毁了", _age);

    [super dealloc];
}
@end

main 函数：

#import <Foundation/Foundation.h>
#import "Person.h"
#import "GoodPerson.h"

/*
1.系统自带的方法里面没有包含alloc、new、copy，说明返回的对象都是autorelease的

2.开发中经常会提供一些类方法，快速创建一个已经autorelease过的对象
1> 创建对象时不要直接用类名，一般用self
+ (id)person
{
return [[[self alloc] init] autorelease];
}
*/

int main()
{
    @autoreleasepool {
        Person *p = [Person personWithAge:100];


        GoodPerson *p2 = [GoodPerson personWithAge:10];

        p2.money = 100;
    }
    return 0;
}

void test()
{
    Person *p = [[Person alloc] init];

    p.age = 200;

    [p release];


    @autoreleasepool
    {
        //        Person *p2 = [Person person];
        //
        //        p2.age = 100;

        Person *p2 = [Person personWithAge:100];

        //        Person *p2 = [[[Person alloc] init] autorelease];
        //
        //        p2.age = 300;


        NSString *str = @"123123";

        NSString *str2 = [NSString stringWithFormat:@"age is %d", 10];

        NSNumber *num = [[NSNumber alloc] initWithInt:10];
        [num release];


        NSNumber *num2 = [NSNumber numberWithInt:100];
    }
}

代码分析：写一个创建autorelease的方法，还可以进行初始化，一定要用self 动态创建，这样子类也可以调用。

六、ARC机制：

1. 概念：ARC是Xcode的编译器功能，自动检测哪里需要有release

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

      3. ARC特点：
         1). 不允许调用release、retain、retainCount
        2). 允许重写dealloc，但是不允许调用[super dealloc]

4. @property的参数：

           1). strong ：成员变量是强指针（适用于OC对象类型，默认指针都是强指针）
           2). weak ：成员变量是弱指针（适用于OC对象类型，一般用在循环使用中）
           3). assign : 适用于非OC对象类型

代码示例：

Dog 类：

#import <Foundation/Foundation.h>

@class Person;

@interface Dog : NSObject

@property (nonatomic, weak) Person *person;

@end

#import "Dog.h"

@implementation Dog
- (void)dealloc
{
NSLog(@"Dog--dealloc");
}
@end

Person 类：

#import <Foundation/Foundation.h>

@class Dog;

@interface Person : NSObject

@property (nonatomic, strong) Dog *dog;

@end

#import "Person.h"

@implementation Person

- (void)dealloc
{
NSLog(@"Person--dealloc");
}

@end

man 函数：

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Dog.h"

int main()
{
    Person *p = [[Person alloc] init];


    Dog *d = [[Dog alloc] init];
    p.dog = d;
    d.person = p;

return 0;
}

代码分析：ARC中参数类型指明是strong或者weak或者assign

5. 循环引用总结：

ARC：

一端用strong 一端用weak

非ARC：

一端用retain 一端用assign

6. ARC和非ARC文件互转：

ARC文件转非ARC文件：

-fno-objc-arc

非ARC文件转ARC文件：

-f-objc-arc

总结：内存管理只要啊找规范一般不会出问题，在用了ARC机制，不用担心内存泄露，减少垃圾代码。

wu417284911

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——OC—内存管理

OC—内存管理一、内存的概念：当app所占内存较多时，会回收一些不使用的对象，变量。基础数据类型存放在内存栈中，系统会自动回收，OC对象存放在内存堆中，系统不会自动回收，这就要求我们手动释放内存。二、引用计数器： 1. 本质：引用计数器存在对象内存中，占用4个字节。 2. 作用：用来表示对象当前被以用的次数。 3. 特点：
复制链接

扫一扫

专栏目录