美文网首页大数据 爬虫Python AI Sql程序员
09-Python面向对象-对象的生命周期,以及周期方法

09-Python面向对象-对象的生命周期,以及周期方法

作者: 撩课学院 | 来源:发表于2018-12-08 10:01 被阅读5次

学习地址:

撩课-Python大数据+人工智能1
撩课-Python大数据+人工智能2
撩课-Python大数据+人工智能3
撩课-Python大数据+人工智能4
撩课-Python大数据+人工智能5
撩课-Python大数据+人工智能6
撩课-Python-GUI编程-PyQt5

1.概念

生命周期

            指的是一个对象, 从诞生到消亡的过程
            当一个对象被创建时, 会在内存中分配相应的内存空间进行存储
            当这个对象不再使用, 为了节约内存, 就会把这个对象释放

2.涉及问题

        如何监听一个对象的生命过程?
        Python是如何掌控一个对象的生命?

3.监听对象生命周期

        __new__方法
            当我们创建一个对象是, 用于给这个对象分配内存的方法
            通过拦截这个方法, 可以修改对象的创建过程
                比如:单例设计模式
        __init__方法
            每个对象实例化的时候,都会自动执行这个方法
            可以在这个方法里面,初始化一些实例属性
        __del__方法
            当对象被释放的时候调用这个方法
            可用于在这个方法中清理资源

4.内存管理机制

存储方面

            1. 在Python中万物皆对象
                不存在基本数据类型
                0,  1.2,  True, False, "abc"
                    这些全都是对象
            2. 所有对象, 都会在内存中开辟一块空间进行存储
                会根据不同的类型以及内容, 开辟不同的空间大小进行存储
                返回该空间的地址给外界接收(称为"引用"), 用于后续对这个对象的操作
                    可通过id()函数获取内存地址(10进制)
                    通过hex()函数可以查看对应的16进制地址
            3. 对于整数和短小的字符, Python会进行缓存; 不会创建多个相同对象
                此时, 被多次赋值, 只会有多份引用
            4. 容器对象, 存储的其他对象, 仅仅是其他对象的引用, 并不是其他对象本身
                比如字典, 列表, 元组这些"容器对象"
                全局变量是由一个大字典进行引用
                    global()查看

垃圾回收方面

1).引用计数器

概念

                    一个对象, 会记录着自身被引用的个数
                    每增加一个引用, 这个对象的引用计数会自动+1
                    每减少一个引用, 这个对象的引用计数会自动-1

举例

                    引用计数+1场景
                        对象被创建
                            p1 = Person()
                        对象被引用
                            p2 = p1
                        对象被作为参数,传入到一个函数中
                            log(p1)
                            这里注意会+2, 因为内部有两个属性引用着这个参数
                        对象作为一个元素,存储在容器中
                            l = [p1]
                    引用计数-1场景
                        对象的别名被显式销毁
                            del p1
                        对象的别名被赋予新的对象
                            p1 = 123
                        一个对象离开它的作用域
                            一个函数执行完毕时
                            内部的局部变量关联的对象, 它的引用计数就会-1
                        对象所在的容器被销毁,或从容器中删除对象

查看引用计数

                    import sys
                    sys.getrefcount(对象)
                        注意会大一

垃圾回收

主要作用

                    从经历过"引用计数器机制"仍未被释放的对象中, 找到"循环引用", 干掉相关对象底层机制(了解&难)

怎样找到"循环引用"?

                         1. 收集所有的"容器对象", 通过一个双向链表进行引用
                            容器对象
                                可以引用其他对象的对象
                                    列表
                                    元组
                                    字典
                                    自定义类对象
                                    ...
                            非容器对象
                                不能引用其他对象的对象
                                    数值
                                    字符串
                                    布尔
                                    ...
                                注意: 针对于这些对象的内存, 有其他的管理机制
                        2. 针对于每一个"容器对象", 通过一个变量gc_refs来记录当前对应的引用计数
                        3. 对于每个"容器对象",找到它引用的"容器对象", 并将这个"容器对象"的引用计数 -1
                        4. 经过步骤3之后, 如果一个"容器对象"的引用计数为0, 就代表这玩意可以被回收了, 肯定是"循环引用"导致它活到现在的

如何提升查找"循环引用"的性能?

                        如果程序当中创建了很多个对象, 而针对于每一个对象都要参与"检测"过程; 则会非常的耗费性能
                        所以, 基于这个问题, 产生了一种假设:
                            越命大的对象, 越长寿
                            假设一个对象10次检测都没给它干掉, 那认定这个对象一定很长寿, 就减少这货的"检测频率"
                        基于这种假设, 设计了一套机制
                            分代回收
                                机制
                                    1. 默认一个对象被创建出来后, 属于 0 代
                                    2. 如果经历过这一代"垃圾回收"后, 依然存活, 则划分到下一代
                                    3. "垃圾回收"的周期顺序为
                                        0代"垃圾回收"一定次数, 会触发 0代和1代回收
                                        1代"垃圾回收"一定次数, 会触发0代, 1代和2代回收
                                查看和设置相关参数
                                    import gc
                                    print(gc.get_threshold())
                                    gc.set_threshold(700, 10, 5)
                            垃圾回收器当中, 新增的对象个数-消亡的对象个数 , 达到一定的阈值时, 才会触发, 垃圾检测

垃圾回收时机(掌握&简单)

                    1. 自动回收
                        触发条件
                            开启垃圾回收机制
                                gc.enable()
                                    开启垃圾回收机制(默认开启)
                                gc.disable()
                                    关闭垃圾回收机制
                                gc.isenabled()
                                    判定是否开启
                            并且
                            达到了垃圾回收的阈值
                                垃圾回收器中, 新增的对象个数和释放的对象个数之差到达某个阈值
                                涉及方法
                                    gc.get_threshold()
                                        获取自动回收阈值
                                    gc.set_threshold()
                                        设置自动回收阈值
                    2. 手动回收
                        触发条件
                            gc.collect()
                            执行一次垃圾回收(开关状态无效)

特殊场景

场景条件

                    Python2.x版本下, 循环引用, 并且有一个对象都实现了__del__方法
                        概念
                            两个对象互相引用对象, 谁的引用计数都是1
                        两个对象都

导致结果

                    无法释放, 进行内存回收

底层原因

                    无法判别先释放哪个对象, 调用哪一个del方法

解决思路

                    手动解除循环引用
                    方式1
                        预防
                            尽可能避免循环引用产生
                        实现
                            一方使用弱引用代替
                    方式2
                        治疗
                            在循环引用的产生的前提下
                        实现
                            当删除一个引用, 确定以后不再使用时, 手动清空对其他容器对象的引用
                    测量对象的引用个数
                          辅助工具
                          objgraph
                          http://mg.pov.lt/objgraph/
                            xdot
                            graphviz

相关文章

网友评论

    本文标题:09-Python面向对象-对象的生命周期,以及周期方法

    本文链接:https://www.haomeiwen.com/subject/pkeycqtx.html