Python GIL 在 Linux 下的实现

在Python初始化多线程环境这部分Linux和Windows一样，就是把initialized变量设为1，并没有做其它的事情。Linux下的GIL实现有两套，由USE_SEMAPHORES宏决定。由名字就可以看出一种实现是使用信号量，一种是不使用信号量的。主要代码都在Python/thread_pthread.h中。

在Python中，GIL的数据结构为PyThread_type_lock，它是一个指向void的指针，这也是因为不同平台实现不同，无法确定一个具体的类型。对GIL的操作共有4种，分别是PyThread_allocate_lock，PyThread_free_lock，PyThread_acquire_lock，PyThread_release_lock。分别执行创建、销毁、锁、解锁GIL的动作。在Python内部还有一个变量会影响到线程請求GIL时的行为，这就是waitflag，如果waitflag为True，那么线程将被阻塞在請求GIL的操作上，反之非阻塞。下面分别分析两种不同的实现。

一、使用信号量

使用信号量时的实现相当地简单明了。GIL就是一个信号量（sem_t）。直接上代码（有精简）。

PyThread_type_lock
PyThread_allocate_lock(void)
{
    sem_t *lock;
    int status, error = 0;

    lock = (sem_t *)malloc(sizeof(sem_t));

    if (lock) {
        status = sem_init(lock,0,1);
    }

    return (PyThread_type_lock)lock;
}

void
PyThread_free_lock(PyThread_type_lock lock)
{
    sem_t *thelock = (sem_t *)lock;
    int status, error = 0;

    status = sem_destroy(thelock);

    free((void *)thelock);
}

/*
* As of February 2002, Cygwin thread implementations mistakenly report error
* codes in the return value of the sem_ calls (like the pthread_ functions).
* Correct implementations return -1 and put the code in errno. This supports
* either.
*/
static int
fix_status(int status)
{
    return (status == -1) ? errno : status;
}

int
PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
{
    int success;
    sem_t *thelock = (sem_t *)lock;
    int status, error = 0;

        // [1]
    do {
        if (waitflag)
            status = fix_status(sem_wait(thelock));
        else
            status = fix_status(sem_trywait(thelock));
    } while (status == EINTR); /* Retry if interrupted by a signal */

    if (waitflag) {
        CHECK_STATUS("sem_wait");
    } else if (status != EAGAIN) {
        CHECK_STATUS("sem_trywait");
    }

    success = (status == 0) ? 1 : 0;

    return success;
}

void
PyThread_release_lock(PyThread_type_lock lock)
{
    sem_t *thelock = (sem_t *)lock;
    int status, error = 0;

    status = sem_post(thelock);
}

在代码中看到的sem_*开头的函数是符合POSIX的信号量操作函数，可以看到Python其实就是对信号量的操作进行了一下包装，而在[1]处的代码则保证請求锁这个操作不会被信号所中断，看过Unix Networking Programming的应该会对这样的語句很熟悉吧。

二、使用一个自定义结构

这种情况稍微复杂一点点。先来看看在这种情况下GIL是个什么东西。

/* A pthread mutex isn't sufficient to model the Python lock type
* because, according to Draft 5 of the docs (P1003.4a/D5), both of the
* following are undefined:
*  -> a thread tries to lock a mutex it already has locked
*  -> a thread tries to unlock a mutex locked by a different thread
* pthread mutexes are designed for serializing threads over short pieces
* of code anyway, so wouldn't be an appropriate implementation of
* Python's locks regardless.
*
* The pthread_lock struct implements a Python lock as a "locked?" bit
* and a <condition, mutex> pair.  In general, if the bit can be acquired
* instantly, it is, else the pair is used to block the thread until the
* bit is cleared.     9 May 1994 tim@ksr.com
*/

typedef struct {
    char             locked; /* 0=unlocked, 1=locked */
    /* a <cond, mutex> pair to handle an acquire of a locked lock */
    pthread_cond_t   lock_released;
    pthread_mutex_t  mut;
} pthread_lock;

可以看到Python自定义了一个struct，其中的locked属性用来表示GIL是否被锁，lock_released和mut共同来实现解锁和锁操作。为什么要这样做呢？注意代码中的注释，可以看到pthread_mutex在两种情况下的行为是不可以预测的：一个线程再次請求被它占有的锁和請求解锁属于另一个线程的锁。我又找了找这方面的资料（链接），发现pthread_mutex有一个kind属性，它可能是fast，recursive或error checking。不同kind属性的pthread_mutex在上述两个操作下的行为是不相同的，而这几个属性都是NP，也就是Non-Portable的，并不通用。在注释中还提到了设计理念的原因，不过这个我就没有太多研究了。接下来看看具体的对GIL的操作。

PyThread_type_lock
PyThread_allocate_lock(void)
{
    pthread_lock *lock;
    int status, error = 0;

    lock = (pthread_lock *) malloc(sizeof(pthread_lock));
    if (lock) {
        memset((void *)lock, '\0', sizeof(pthread_lock));
        lock->locked = 0;

        status = pthread_mutex_init(&lock->mut,
                        pthread_mutexattr_default);

        status = pthread_cond_init(&lock->lock_released,
                       pthread_condattr_default);
    }

    return (PyThread_type_lock) lock;
}

void
PyThread_free_lock(PyThread_type_lock lock)
{
    pthread_lock *thelock = (pthread_lock *)lock;
    int status, error = 0;

    status = pthread_mutex_destroy( &thelock->mut );

    status = pthread_cond_destroy( &thelock->lock_released );

    free((void *)thelock);
}

可以看到创建和销毁GIL的代码还是非常地直观地，就是分别地创建和销毁其中的lock_released和mut。請求锁和解锁的操作稍微绕了一点点弯，如下。

int
PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
{
    int success;
    pthread_lock *thelock = (pthread_lock *)lock;
    int status, error = 0;

    status = pthread_mutex_lock( &thelock->mut );
    success = thelock->locked == 0;

    if ( !success && waitflag ) {
        /* continue trying until we get the lock */

        /* mut must be locked by me -- part of the condition
         * protocol */
        while ( thelock->locked ) {
            status = pthread_cond_wait(&thelock->lock_released,
                           &thelock->mut);
        }
        success = 1;
    }
    if (success) thelock->locked = 1;
    status = pthread_mutex_unlock( &thelock->mut );

    if (error) success = 0;
    return success;
}

void
PyThread_release_lock(PyThread_type_lock lock)
{
    pthread_lock *thelock = (pthread_lock *)lock;
    int status, error = 0;

    status = pthread_mutex_lock( &thelock->mut );

    thelock->locked = 0;

    status = pthread_mutex_unlock( &thelock->mut );

    /* wake up someone (anyone, if any) waiting on the lock */
    status = pthread_cond_signal( &thelock->lock_released );

具体每一步各个参数返回什么值可以自己手动拿张纸画画，还是很好推的。直接给出结论：GIL在上述两种情况下的动作分别是：当一个线程试图去锁定已经被它锁定过的GIL时，阻塞（waitflag == 1）或返回失败（waitflag == 0），分别类似于kind属性为fast 和 error checking的pthread_mutex；当一个线程试图去解锁并不是由它锁定的GIL时，马上返回，并成功解锁，类似于kink为fast的pthread_mutex。至此解析完成。