对PyStringObject的认识(Intern机制)

本章主要讲讲我对Python中string的实现的认识。PyStringObject的定义如下：
typedef struct {
    PyObject_VAR_HEAD
    long ob_shash;
    int ob_sstate;
    char ob_sval[1];
} PyStringObject;
可以看到，PyStringObject的头部是PyObject_VAR_HEAD,说明PyStringObject实际上是一个变长对象，而要注意的是，Python中的string是一个不可变对象。这是不是与前面的变长有点矛盾？其实不矛盾，前面的变长对象指的是string在创建的时候长度不一定，“p"长度为1，”Python“长度为6，长度值存在于PyObject_VAR_Head里面的ob_size里面。而后面的不可变指的是一旦Python的string对象创建出来之后，它在内存中就是不可变的了。所以如果对string进行”+“操作，得到的结果其实是一个新的string 对象。
ob_shash其实是这个string的哈希值，这样可以避免每次都计算这个string的哈希值。如果还没计算过的话，默认值为-1.
ob_sstate表示的是该string 有没有被intern机制处理过（接下来马上就讲intern机制）
ob_sval看似数组，但其实只有一个元素，指向我们保存的字符串数组的头部。
好，接下来将Python string中的intern机制。
首先来看如合创建PyStringObject对象：
PyObject * PyString_FromString(const char *str)
{
    register size_t size;
    register PyStringObject *op;
    /* 省略了不少中间代码*/
    op = (PyStringObject *)PyObject_MALLOC(PyStringObject_SIZE + size);
    if (op == NULL)
        return PyErr_NoMemory();
    PyObject_INIT_VAR(op, &PyString_Type, size);
    op->ob_shash = -1;
    op->ob_sstate = SSTATE_NOT_INTERNED;
    Py_MEMCPY(op->ob_sval, str, size+1);
    /* share short strings */
    if (size == 0) {
/* 省略了不少中间代码*/
    } else if (size == 1) {
/* 省略了不少中间代码*/
 }  
  return (PyObject *) op;
}

如果我们写上以下代码：
a = "python"
b = "python"
c = "Python"
  那根据这个创建代码Python是肯定要创建三个PyStringObject了，再多几个，岂不是会很浪费内存？聪明的Python肯定不会这么做。于是就有了Intern机制
Intern机制的目的在于，在Python运行系统中，不论用户创建了多少像上面的a,b,c，只有一个”Python“对象，其他的都是指向这个对象，大家共用这个对象。也就是说，当a创建的时候，Python会对a进行Intern机制处理，然后当b创建的时候，b指向一个PyStringObject temp,通过intern机制发现已经有b与a的对象存储的字符串其实一样，那么就会把b指向a指向的那个对象，这样用来创建b的那个临时对象temp会因为b指向其他对象而进行de_allocate而销毁，这样就不会浪费内存了。
上面代码中的size==0括号的内容其实也就是对nullstring的一种intern机制处理，令所有创建的Null string都指向同一个对象。

下面是intern机制的代码：
static PyObject *interned;
void PyString_InternInPlace(PyObject **p)
{
    register PyStringObject *s = (PyStringObject *)(*p);
    PyObject *t;
    if (s == NULL || !PyString_Check(s))
        Py_FatalError("PyString_InternInPlace: strings only please!");
    /* If it's a string subclass, we don't really know what putting
       it in the interned dict might do. */
    if (!PyString_CheckExact(s))
        return;
    if (PyString_CHECK_INTERNED(s))
        return;
    if (interned == NULL) {
        interned = PyDict_New();
        if (interned == NULL) {
            PyErr_Clear(); /* Don't leave an exception */
            return;
        }
    }
    t = PyDict_GetItem(interned, (PyObject *)s);
    if (t) {
        Py_INCREF(t);
        Py_DECREF(*p);
        *p = t;
        return;
    }


    if (PyDict_SetItem(interned, (PyObject *)s, (PyObject *)s) < 0) {
        PyErr_Clear();
        return;
    }
    /* The two references in interned are not counted by refcnt.
       The string deallocator will take care of this */
    Py_REFCNT(s) -= 2;
    PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
}

其中重要的我已经粗体字表明了，interned的定义是一个PyObject,但从下面的代码可以看出，在interned=nul的时候，interned = PyDict_New();所以它实际上是一个PyDictObject，我们可以暂时理解为c++里面的map对象。对一个PyStringObject对象进行intern机制处理的时候，会通过PyDict_GetItem去从Interned对象中查找有没有一样的已经创建的对象，有的话就直接拿来用，没有的话就说明这种对象是第一次创建，用PyDict_SetItem函数把相应的信息存到interned里面，下次再创建一样的就能从中找到了。
之前在讲PyIntObject的时候有提到过对象池，那么对于PyStringObject，又怎么可能没有呢？对于int，是比较小的整数会一直存在于内存中，那么对于string,为会长度为1的字符创建对象池。
static PyStringObject *characters[UCHAR_MAX + 1];
下面补全上面部分省略的代码：
if (size == 1 && str != NULL) {
        PyObject *t = (PyObject *)op;
        PyString_InternInPlace(&t);
        op = (PyStringObject *)t;
        characters[*str & UCHAR_MAX] = op;
        Py_INCREF(op);
    }

这样，每当创建长度为1的字符串的时候，都会把它存到characters里面，这样之后创建长度为1的字符时，如果检测到已经在characters里面了，就直接返回这个缓冲的对象(如下面代码所示)，不用进行malloc,这也就是该缓冲池的作用

if (size == 1 && str != NULL &&
        (op = characters[*str & UCHAR_MAX]) != NULL)
    {
#ifdef COUNT_ALLOCS
        one_strings++;
#endif
        Py_INCREF(op);
        return (PyObject *)op;
    }

 好了，觉得PyStringObject重要的一些就在上面了。：）