目录
前言
Python 对象的内存布局
牛刀小试
查看对象的内存地址
copy模块
可变和不可变对象与对象拷贝
代码片段分析
撕开 Python 对象的神秘面纱
首页 后端开发 Python教程 Python的对象拷贝和内存布局怎么实现

Python的对象拷贝和内存布局怎么实现

May 15, 2023 pm 04:37 PM
python

    前言

    你知道下面一些程序片段的输出结果吗?

    a = [1, 2, 3, 4]
    b = a
    print(f"{a = } \t|\t {b = }")
    a[0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制
    a = [1, 2, 3, 4]
    b = a.copy()
    print(f"{a = } \t|\t {b = }")
    a[0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制
    a = [[1, 2, 3], 2, 3, 4]
    b = a.copy()
    print(f"{a = } \t|\t {b = }")
    a[0][0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制
    a = [[1, 2, 3], 2, 3, 4]
    b = copy.copy(a)
    print(f"{a = } \t|\t {b = }")
    a[0][0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    a = [[1, 2, 3], 2, 3, 4]
    b = copy.deepcopy(a)
    print(f"{a = } \t|\t {b = }")
    a[0][0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制

    Python 对象的内存布局

    在 python 当中我们应该如何确定一个对象的内存地址呢?在 Python 当中给我们提供了一个内嵌函数 id() 用于得到一个对象的内存地址:

    a = [1, 2, 3, 4]
    b = a
    print(f"{a = } \t|\t {b = }")
    a[0] = 100
    print(f"{a = } \t|\t {b = }")
    print(f"{id(a) = } \t|\t {id(b) = }")
    # 输出结果
    # a = [1, 2, 3, 4]  |  b = [1, 2, 3, 4]
    # a = [100, 2, 3, 4]  |  b = [100, 2, 3, 4]
    # id(a) = 4393578112  |  id(b) = 4393578112
    登录后复制

    事实上上面的对象内存布局是有一点问题的,或者说是不够准确的,但是也是能够表示出各个对象之间的关系的,我们现在来深入了解一下。在 Cpython 里你可以认为每一个变量都可以认为是一个指针,指向被表示的那个数据,这个指针保存的就是这个 Python 对象的内存地址。

    在 Python 当中,实际上列表保存的指向各个 Python 对象的指针,而不是实际的数据,因此上面的一小段代码,可以用如下的图表示对象在内存当中的布局:

    Python的对象拷贝和内存布局怎么实现

    变量 a 指向内存当中的列表 [1, 2, 3, 4],列表当中有 4 个数据,这四个数据都是指针,而这四个指针指向内存当中 1,2,3,4 这四个数据。可能你会有疑问,这不是有问题吗?都是整型数据为什么不直接在列表当中存放整型数据,为啥还要加一个指针,再指向这个数据呢?

    事实上在 Python 当中,列表当中能够存放任何 Python 对象,比如下面的程序是合法的:

    data = [1, {1:2, 3:4}, {'a', 1, 2, 25.0}, (1, 2, 3), "hello world"]
    登录后复制

    在上面的列表当中第一个到最后一个数据的数据类型为:整型数据,字典,集合,元祖,字符串,现在来看为了实现 Python 的这个特性,指针的特性是不是符合要求呢?每个指针所占用的内存是一样的,因此可以使用一个数组去存储 Python 对象的指针,然后再将这个指针指向真正的 Python 对象!

    牛刀小试

    在经过上面的分析之后,我们来看一下下面的代码,他的内存布局是什么情况:

    data = [[1, 2, 3], 4, 5, 6]
    data_assign = data
    data_copy = data.copy()
    登录后复制

    Python的对象拷贝和内存布局怎么实现

    Python的对象拷贝和内存布局怎么实现

    • data_assign = data,关于这个赋值语句的内存布局我们在之前已经谈到过了,不过我们也再复习一下,这个赋值语句的含义就是 data_assign 和 data 指向的数据是同一个数据,也就是同一个列表。

    • data_copy = data.copy(),这条赋值语句的含义是将 data 指向的数据进行浅拷贝,然后让 data_copy 指向拷贝之后的数据,这里的浅拷贝的意思就是,对列表当中的每一个指针进行拷贝,而不对列表当中指针指向的数据进行拷贝。从上面的对象的内存布局图我们可以看到 data_copy 指向一个新的列表,但是列表当中的指针指向的数据和 data 列表当中的指针指向的数据是一样的,其中 data_copy 使用绿色的箭头进行表示,data 使用黑色的箭头进行表示。

    查看对象的内存地址

    在前面的文章当中我们主要分析了一下对象的内存布局,在本小节我们使用 python 给我们提供一个非常有效的工具去验证这一点。在 python 当中我们可以使用 id() 去查看对象的内存地址,id(a) 就是查看对象 a 所指向的对象的内存地址。

    看下面的程序的输出结果:

    a = [1, 2, 3]
    b = a
    print(f"{id(a) = } {id(b) = }")
    for i in range(len(a)):
        print(f"{i = } {id(a[i]) = } {id(b[i]) = }")
    登录后复制

    根据我们之前的分析,a 和 b 指向的同一块内存,也就说两个变量指向的是同一个 Python 对象,因此上面的多有输出的 id 结果 a 和 b 都是相同的,上面的输出结果如下:

    id(a) = 4392953984 id(b) = 4392953984
    i = 0 id(a[i]) = 4312613104 id(b[i]) = 4312613104
    i = 1 id(a[i]) = 4312613136 id(b[i]) = 4312613136
    i = 2 id(a[i]) = 4312613168 id(b[i]) = 4312613168

    看一下浅拷贝的内存地址:

    a = [[1, 2, 3], 4, 5]
    b = a.copy()
    print(f"{id(a) = } {id(b) = }")
    for i in range(len(a)):
        print(f"{i = } {id(a[i]) = } {id(b[i]) = }")
    登录后复制

    根据我们在前面的分析,调用列表本身的 copy 方法是对列表进行浅拷贝,只拷贝列表的指针数据,并不拷贝列表当中指针指向的真正的数据,因此如果我们对列表当中的数据进行遍历得到指向的对象的地址的话,列表 a 和列表 b 返回的结果是一样的,但是和上一个例子不同的是 a 和 b 指向的列表的本身的地址是不一样的(因为进行了数据拷贝,可以参照下面浅拷贝的结果进行理解)。

    Python的对象拷贝和内存布局怎么实现

    可以结合下面的输出结果和上面的文字进行理解:

    id(a) = 4392953984 id(b) = 4393050112 # 两个对象的输出结果不相等
    i = 0 id(a[i]) = 4393045632 id(b[i]) = 4393045632 # 指向的是同一个内存对象因此内存地址相等 下同
    i = 1 id(a[i]) = 4312613200 id(b[i]) = 4312613200
    i = 2 id(a[i]) = 4312613232 id(b[i]) = 4312613232
    登录后复制

    copy模块

    在 python 里面有一个自带的包 copy ,主要是用于对象的拷贝,在这个模块当中主要有两个方法 copy.copy(x) 和 copy.deepcopy()。

    copy.copy(x) 方法主要是用于浅拷贝,这个方法的含义对于列表来说和列表本身的 x.copy() 方法的意义是一样的,都是进行浅拷贝。这个方法会构造一个新的 python 对象并且会将对象 x 当中所有的数据引用(指针)拷贝一份。

    Python的对象拷贝和内存布局怎么实现

    copy.deepcopy(x) 这个方法主要是对对象 x 进行深拷贝,这里的深拷贝的含义是会构造一个新的对象,会递归的查看对象 x 当中的每一个对象,如果递归查看的对象是一个不可变对象将不会进行拷贝,如果查看到的对象是可变对象的话,将重新开辟一块内存空间,将原来的在对象 x 当中的数据拷贝的新的内存当中。(关于可变和不可变对象我们将在下一个小节仔细分析)

    根据上面的分析我们可以知道深拷贝的花费是比浅拷贝多的,尤其是当一个对象当中有很多子对象的时候,会花费很多时间和内存空间。

    对于 python 对象来说进行深拷贝和浅拷贝的区别主要在于复合对象(对象当中有子对象,比如说列表,元祖、类的实例等等)。这一点主要是和下一小节的可变和不可变对象有关系。

    可变和不可变对象与对象拷贝

    在 python 当中主要有两大类对象,可变对象和不可变对象,所谓可变对象就是对象的内容可以发生改变,不可变对象就是对象的内容不能够发生改变。

    • 可变对象:比如说列表(list),字典(dict),集合(set),字节数组(bytearray),类的实例对象。

    • 不可变对象:整型(int),浮点型(float),复数(complex),字符串,元祖(tuple),不可变集合(frozenset),字节(bytes)。

    看到这里你可能会有疑问了,整数和字符串不是可以修改吗?

    a = 10
    a = 100
    a = "hello"
    a = "world"
    登录后复制

    比如下面的代码是正确的,并不会发生错误,但是事实上其实 a 指向的对象是发生了变化的,第一个对象指向整型或者字符串的时候,如果重新赋一个新的不同的整数或者字符串对象的话,python 会创建一个新的对象,我们可以使用下面的代码进行验证:

    a = 10
    print(f"{id(a) = }")
    a = 100
    print(f"{id(a) = }")
    a = "hello"
    print(f"{id(a) = }")
    a = "world"
    print(f"{id(a) = }")
    登录后复制

    上面的程序的输出结果如下所示:

    id(a) = 4365566480
    id(a) = 4365569360
    id(a) = 4424109232
    id(a) = 4616350128

    可以看到的是当重新赋值之后变量指向的内存对象是发生了变化的(因为内存地址发生了变化),这就是不可变对象,虽然可以对变量重新赋值,但是得到的是一个新对象并不是在原来的对象上进行修改的!

    我们现在来看一下可变对象列表发生修改之后内存地址是怎么发生变化的:

    data = []
    print(f"{id(data) = }")
    data.append(1)
    print(f"{id(data) = }")
    data.append(1)
    print(f"{id(data) = }")
    data.append(1)
    print(f"{id(data) = }")
    data.append(1)
    print(f"{id(data) = }")
    登录后复制

    上面的代码输出结果如下所示:

    id(data) = 4614905664
    id(data) = 4614905664
    id(data) = 4614905664
    id(data) = 4614905664
    id(data) = 4614905664

    从上面的输出结果来看可以知道,当我们往列表当中加入新的数据之后(修改了列表),列表本身的地址并没有发生变化,这就是可变对象。

    我们在前面谈到了深拷贝和浅拷贝,我们现在来分析一下下面的代码:

    data = [1, 2, 3]
    data_copy = copy.copy(data)
    data_deep = copy.deepcopy(data)
    print(f"{id(data ) = } | {id(data_copy) = } | {id(data_deep) = }")
    print(f"{id(data[0]) = } | {id(data_copy[0]) = } | {id(data_deep[0]) = }")
    print(f"{id(data[1]) = } | {id(data_copy[1]) = } | {id(data_deep[1]) = }")
    print(f"{id(data[2]) = } | {id(data_copy[2]) = } | {id(data_deep[2]) = }")
    登录后复制

    上面的代码输出结果如下所示:

    id(data ) = 4620333952 | id(data_copy) = 4619860736 | id(data_deep) = 4621137024
    id(data[0]) = 4365566192 | id(data_copy[0]) = 4365566192 | id(data_deep[0]) = 4365566192
    id(data[1]) = 4365566224 | id(data_copy[1]) = 4365566224 | id(data_deep[1]) = 4365566224
    id(data[2]) = 4365566256 | id(data_copy[2]) = 4365566256 | id(data_deep[2]) = 4365566256

    看到这里你肯定会非常疑惑,为什么深拷贝和浅拷贝指向的内存对象是一样的呢?前列我们可以理解,因为浅拷贝拷贝的是引用,因此他们指向的对象是同一个,但是为什么深拷贝之后指向的内存对象和浅拷贝也是一样的呢?这正是因为列表当中的数据是整型数据,他是一个不可变对象,如果对 data 或者 data_copy 指向的对象进行修改,那么将会指向一个新的对象并不会直接修改原来的对象,因此对于不可变对象其实是不用开辟一块新的内存空间在重新赋值的,因为这块内存中的对象是不会发生改变的。

    我们再来看一个可拷贝的对象:

    data = [[1], [2], [3]]
    data_copy = copy.copy(data)
    data_deep = copy.deepcopy(data)
    print(f"{id(data ) = } | {id(data_copy) = } | {id(data_deep) = }")
    print(f"{id(data[0]) = } | {id(data_copy[0]) = } | {id(data_deep[0]) = }")
    print(f"{id(data[1]) = } | {id(data_copy[1]) = } | {id(data_deep[1]) = }")
    print(f"{id(data[2]) = } | {id(data_copy[2]) = } | {id(data_deep[2]) = }")
    登录后复制

    上面的代码输出结果如下所示:

    id(data ) = 4619403712 | id(data_copy) = 4617239424 | id(data_deep) = 4620032640
    id(data[0]) = 4620112640 | id(data_copy[0]) = 4620112640 | id(data_deep[0]) = 4620333952
    id(data[1]) = 4619848128 | id(data_copy[1]) = 4619848128 | id(data_deep[1]) = 4621272448
    id(data[2]) = 4620473280 | id(data_copy[2]) = 4620473280 | id(data_deep[2]) = 4621275840

    从上面程序的输出结果我们可以看到,当列表当中保存的是一个可变对象的时候,如果我们进行深拷贝将创建一个全新的对象(深拷贝的对象内存地址和浅拷贝的不一样)。

    代码片段分析

    经过上面的学习对于在本篇文章开头提出的问题对于你来说应该是很简单的,我们现在来分析一下这几个代码片段:

    a = [1, 2, 3, 4]
    b = a
    print(f"{a = } \t|\t {b = }")
    a[0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制

    这个很简单啦,a 和 b 不同的变量指向同一个列表,a 中间的数据发生变化,那么 b 的数据也会发生变化,输出结果如下所示:

    a = [1, 2, 3, 4] | b = [1, 2, 3, 4]
    a = [100, 2, 3, 4] | b = [100, 2, 3, 4]
    id(a) = 4614458816 | id(b) = 4614458816

    我们再来看一下第二个代码片段

    a = [1, 2, 3, 4]
    b = a.copy()
    print(f"{a = } \t|\t {b = }")
    a[0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制

    因为 b 是 a 的一个浅拷贝,所以 a 和 b 指向的是不同的列表,但是列表当中数据的指向是相同的,但是由于整型数据是不可变数据,当a[0] 发生变化的时候,并不会修改原来的数据,而是会在内存当中创建一个新的整型数据,因此列表 b 的内容并不会发生变化。因此上面的代码输出结果如下所示:

    a = [1, 2, 3, 4]  |  b = [1, 2, 3, 4]
    a = [100, 2, 3, 4]  |  b = [1, 2, 3, 4]
    登录后复制

    再来看一下第三个片段:

    a = [[1, 2, 3], 2, 3, 4]
    b = a.copy()
    print(f"{a = } \t|\t {b = }")
    a[0][0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制

    这个和第二个片段的分析是相似的,但是 a[0] 是一个可变对象,因此进行数据修改的时候,a[0] 的指向没有发生变化,因此 a 修改的内容会影响 b。

    a = [[1, 2, 3], 2, 3, 4]  |  b = [[1, 2, 3], 2, 3, 4]
    a = [[100, 2, 3], 2, 3, 4]  |  b = [[100, 2, 3], 2, 3, 4]
    登录后复制

    最后一个片段:

    a = [[1, 2, 3], 2, 3, 4]
    b = copy.deepcopy(a)
    print(f"{a = } \t|\t {b = }")
    a[0][0] = 100
    print(f"{a = } \t|\t {b = }")
    登录后复制
    登录后复制

    深拷贝会在内存当中重新创建一个和a[0]相同的对象,并且让 b[0] 指向这个对象,因此修改 a[0],并不会影响 b[0],因此输出结果如下所示:

    a = [[1, 2, 3], 2, 3, 4]  |  b = [[1, 2, 3], 2, 3, 4]
    a = [[100, 2, 3], 2, 3, 4]  |  b = [[1, 2, 3], 2, 3, 4]
    登录后复制

    撕开 Python 对象的神秘面纱

    我们现在简要看一下 Cpython 是如何实现 list 数据结构的,在 list 当中到底定义了一些什么东西:

    typedef struct {
        PyObject_VAR_HEAD
        /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
        PyObject **ob_item;
    
        /* ob_item contains space for 'allocated' elements.  The number
         * currently in use is ob_size.
         * Invariants:
         *     0 <= ob_size <= allocated
         *     len(list) == ob_size
         *     ob_item == NULL implies ob_size == allocated == 0
         * list.sort() temporarily sets allocated to -1 to detect mutations.
         *
         * Items must normally not be NULL, except during construction when
         * the list is not yet visible outside the function that builds it.
         */
        Py_ssize_t allocated;
    } PyListObject;
    登录后复制

    在上面定义的结构体当中 :

    allocated 表示分配的内存空间的数量,也就是能够存储指针的数量,当所有的空间用完之后需要再次申请内存空间。

    ob_item 指向内存当中真正存储指向 python 对象指针的数组,比如说我们想得到列表当中第一个对象的指针的话就是 list->ob_item[0],如果要得到真正的数据的话就是 *(list->ob_item[0])。

    PyObject_VAR_HEAD 是一个宏,会在结构体当中定一个子结构体,这个子结构体的定义如下:

    typedef struct {
        PyObject ob_base;
        Py_ssize_t ob_size; /* Number of items in variable part */
    } PyVarObject;
    登录后复制

    这里我们不去谈对象 PyObject 了,主要说一下 ob_size,他表示列表当中存储了多少个数据,这个和 allocated 不一样,allocated 表示 ob_item 指向的数组一共有多少个空间,ob_size 表示这个数组存储了多少个数据 ob_size <= allocated。

    在了解列表的结构体之后我们现在应该能够理解之前的内存布局了,所有的列表并不存储真正的数据而是存储指向这些数据的指针。

    以上是Python的对象拷贝和内存布局怎么实现的详细内容。更多信息请关注PHP中文网其他相关文章!

    本站声明
    本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn

    热AI工具

    Undresser.AI Undress

    Undresser.AI Undress

    人工智能驱动的应用程序,用于创建逼真的裸体照片

    AI Clothes Remover

    AI Clothes Remover

    用于从照片中去除衣服的在线人工智能工具。

    Undress AI Tool

    Undress AI Tool

    免费脱衣服图片

    Clothoff.io

    Clothoff.io

    AI脱衣机

    AI Hentai Generator

    AI Hentai Generator

    免费生成ai无尽的。

    热门文章

    R.E.P.O.能量晶体解释及其做什么(黄色晶体)
    3 周前 By 尊渡假赌尊渡假赌尊渡假赌
    R.E.P.O.最佳图形设置
    3 周前 By 尊渡假赌尊渡假赌尊渡假赌
    R.E.P.O.如果您听不到任何人,如何修复音频
    3 周前 By 尊渡假赌尊渡假赌尊渡假赌
    WWE 2K25:如何解锁Myrise中的所有内容
    4 周前 By 尊渡假赌尊渡假赌尊渡假赌

    热工具

    记事本++7.3.1

    记事本++7.3.1

    好用且免费的代码编辑器

    SublimeText3汉化版

    SublimeText3汉化版

    中文版,非常好用

    禅工作室 13.0.1

    禅工作室 13.0.1

    功能强大的PHP集成开发环境

    Dreamweaver CS6

    Dreamweaver CS6

    视觉化网页开发工具

    SublimeText3 Mac版

    SublimeText3 Mac版

    神级代码编辑软件(SublimeText3)

    mysql 是否要付费 mysql 是否要付费 Apr 08, 2025 pm 05:36 PM

    MySQL 有免费的社区版和收费的企业版。社区版可免费使用和修改,但支持有限,适合稳定性要求不高、技术能力强的应用。企业版提供全面商业支持,适合需要稳定可靠、高性能数据库且愿意为支持买单的应用。选择版本时考虑的因素包括应用关键性、预算和技术技能。没有完美的选项,只有最合适的方案,需根据具体情况谨慎选择。

    mysql安装后怎么使用 mysql安装后怎么使用 Apr 08, 2025 am 11:48 AM

    文章介绍了MySQL数据库的上手操作。首先,需安装MySQL客户端,如MySQLWorkbench或命令行客户端。1.使用mysql-uroot-p命令连接服务器,并使用root账户密码登录;2.使用CREATEDATABASE创建数据库,USE选择数据库;3.使用CREATETABLE创建表,定义字段及数据类型;4.使用INSERTINTO插入数据,SELECT查询数据,UPDATE更新数据,DELETE删除数据。熟练掌握这些步骤,并学习处理常见问题和优化数据库性能,才能高效使用MySQL。

    mySQL下载完安装不了 mySQL下载完安装不了 Apr 08, 2025 am 11:24 AM

    MySQL安装失败的原因主要有:1.权限问题,需以管理员身份运行或使用sudo命令;2.依赖项缺失,需安装相关开发包;3.端口冲突,需关闭占用3306端口的程序或修改配置文件;4.安装包损坏,需重新下载并验证完整性;5.环境变量配置错误,需根据操作系统正确配置环境变量。解决这些问题,仔细检查每个步骤,就能顺利安装MySQL。

    mysql下载文件损坏无法安装的修复方案 mysql下载文件损坏无法安装的修复方案 Apr 08, 2025 am 11:21 AM

    MySQL下载文件损坏,咋整?哎,下载个MySQL都能遇到文件损坏,这年头真是不容易啊!这篇文章就来聊聊怎么解决这个问题,让大家少走弯路。读完之后,你不仅能修复损坏的MySQL安装包,还能对下载和安装过程有更深入的理解,避免以后再踩坑。先说说为啥下载文件会损坏这原因可多了去了,网络问题是罪魁祸首,下载过程中断、网络不稳定都可能导致文件损坏。还有就是下载源本身的问题,服务器文件本身就坏了,你下载下来当然也是坏的。另外,一些杀毒软件过度“热情”的扫描也可能造成文件损坏。诊断问题:确定文件是否真的损坏

    mysql 需要互联网吗 mysql 需要互联网吗 Apr 08, 2025 pm 02:18 PM

    MySQL 可在无需网络连接的情况下运行,进行基本的数据存储和管理。但是,对于与其他系统交互、远程访问或使用高级功能(如复制和集群)的情况,则需要网络连接。此外,安全措施(如防火墙)、性能优化(选择合适的网络连接)和数据备份对于连接到互联网的 MySQL 数据库至关重要。

    mysql安装后怎么优化数据库性能 mysql安装后怎么优化数据库性能 Apr 08, 2025 am 11:36 AM

    MySQL性能优化需从安装配置、索引及查询优化、监控与调优三个方面入手。1.安装后需根据服务器配置调整my.cnf文件,例如innodb_buffer_pool_size参数,并关闭query_cache_size;2.创建合适的索引,避免索引过多,并优化查询语句,例如使用EXPLAIN命令分析执行计划;3.利用MySQL自带监控工具(SHOWPROCESSLIST,SHOWSTATUS)监控数据库运行状况,定期备份和整理数据库。通过这些步骤,持续优化,才能提升MySQL数据库性能。

    如何针对高负载应用程序优化 MySQL 性能? 如何针对高负载应用程序优化 MySQL 性能? Apr 08, 2025 pm 06:03 PM

    MySQL数据库性能优化指南在资源密集型应用中,MySQL数据库扮演着至关重要的角色,负责管理海量事务。然而,随着应用规模的扩大,数据库性能瓶颈往往成为制约因素。本文将探讨一系列行之有效的MySQL性能优化策略,确保您的应用在高负载下依然保持高效响应。我们将结合实际案例,深入讲解索引、查询优化、数据库设计以及缓存等关键技术。1.数据库架构设计优化合理的数据库架构是MySQL性能优化的基石。以下是一些核心原则:选择合适的数据类型选择最小的、符合需求的数据类型,既能节省存储空间,又能提升数据处理速度

    MySQL安装后服务无法启动的解决办法 MySQL安装后服务无法启动的解决办法 Apr 08, 2025 am 11:18 AM

    MySQL拒启动?别慌,咱来排查!很多朋友安装完MySQL后,发现服务死活启动不了,心里那个急啊!别急,这篇文章带你从容应对,揪出幕后黑手!读完后,你不仅能解决这个问题,还能提升对MySQL服务的理解,以及排查问题的思路,成为一名更强大的数据库管理员!MySQL服务启动失败,原因五花八门,从简单的配置错误到复杂的系统问题都有可能。咱们先从最常见的几个方面入手。基础知识:服务启动流程简述MySQL服务启动,简单来说,就是操作系统加载MySQL相关的文件,然后启动MySQL守护进程。这其中涉及到配置

    See all articles