Linux线程库与线程库封装¶

// ...
std::string toHex(pthread_t num)
{
    char buffer[1024];
    snprintf(buffer, sizeof(buffer), "0x%lx", num);

    return buffer;
}

void *routine(void *arg)
{
    std::cout << toHex(pthread_self()) << std::endl;

    return NULL;
}
// ...

struct pthread* pd = ...;
pthread_t tid = (pthread_t)pd;

/* Thread descriptor data structure.  */
struct pthread
{
    // ...
    /* This descriptor's link on the `stack_used' or `__stack_user' list.  */
    list_t list;

    // 线程id
    pid_t tid;

    // 当前进程pid
    pid_t pid;

    // ...

    // 判断用户是否传入自定义栈
    bool user_stack;

    // ...

    // 存储线程执行函数的返回值
    void *result;

    // 线程执行函数和参数
    void *(*start_routine) (void *);
    void *arg;

    // 线程栈指针
    void *stackblock;
    // 线程栈大小
    size_t stackblock_size;

    // ...
} __attribute ((aligned (TCB_ALIGNMENT)));

int clone(int (*fn)(void *), void *stack, int flags,
            void * arg, ...  /* pid_t * parent_tid, void * tls,
                                pid_t * child_tid */ );

int __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr,
              void *(*start_routine) (void *), void *arg)
{
    // ...

    // 线程属性，就是pthread_create函数的第二个参数，默认情况下传递NULL
    const struct pthread_attr *iattr = (struct pthread_attr *) attr;
    // 创建默认属性
    struct pthread_attr default_attr;

    // ...

    // 如果iattr为NULL，就使用默认属性
    if (iattr == NULL)
    {
        // ...

        // 使用默认属性
        iattr = &default_attr;
    }

    // 创建线程结构体
    struct pthread *pd = NULL;

    // 调用ALLOCATE_STACK申请struct pthread对象
    int err = ALLOCATE_STACK(iattr, &pd);

    // ...

    // 设置线程执行函数和对应的参数到线程结构体对象中
    pd->start_routine = start_routine;
    pd->arg = arg;

    // ...

    // 设置参数pthread* newthread为线程结构体对象的地址，即设置线程id为结构体对象的地址
    *newthread = (pthread_t) pd;

    // ...

    if (__glibc_unlikely (report_thread_creation (pd)))
    {
        // ...

        // 创建线程
        retval = create_thread(pd, iattr, STACK_VARIABLES_ARGS);

        // ...
    }

    // ...
}
// 版本确认信息，如果用的库是GLIBC_2_1，则使用__pthread_create_2_1
versioned_symbol (libpthread, __pthread_create_2_1, pthread_create, GLIBC_2_1);

struct pthread_attr
{
    // ...

    // 线程栈空间指针
    void *stackaddr;
    // 线程栈大小
    size_t stacksize;

    // ...
};

// 创建一个宏，通过属性和struct pthread指针调用allocate_stack函数
# define ALLOCATE_STACK(attr, pd) allocate_stack (attr, pd, &stackaddr)

static int allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
        ALLOCATE_STACK_PARMS)
{
    struct pthread *pd;
    size_t size;

    // ...

    // 设置线程栈大小，如果用户已经指定，则使用用户指定的大小，否则使用默认大小
    if (attr->stacksize != 0)
        size = attr->stacksize;
    else
    {
        // ...
        size = __default_pthread_attr.stacksize;
        // ...
    }

    if (__glibc_unlikely (attr->flags & ATTR_FLAG_STACKADDR))
    {
        // ...
    }
    else
    {
        // ...

        // 先从pthread缓存中申请空间
        reqsize = size;
        pd = get_cached_stack (&size, &mem);
        if (pd == NULL)
        {
            // ...

            // 缓存申请失败，就到堆空间中申请私有的匿名内存空间
            mem = __mmap (NULL, size, (guardsize == 0) ? prot : PROT_NONE,
                    MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);

            // ...

            /* Remember the stack-related values.  */
            // 使用线程对象记录创建的空间和大小
            pd->stackblock = mem;
            pd->stackblock_size = size;

            // ...
        }
    }

    // 二级指针，用于返回struct pthread的地址
    *pdp = pd;

    // ...

    return 0;
}

static int create_thread(struct pthread *pd, const struct pthread_attr *attr,
STACK_VARIABLES_PARMS)
{
    int clone_flags = (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGNAL |
        CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID | CLONE_SYSVSEM

    // ...

    if (__builtin_expect(THREAD_GETMEM(THREAD_SELF, report_events), 0))
    {
        // ...
        int res = do_clone(pd, attr, clone_flags, start_thread, STACK_VARIABLES_ARGS, 1);

        // ...
    }

    // ...
    return res;
}

static int do_clone(struct pthread *pd, const struct pthread_attr *attr,
int clone_flags, int (*fct)(void *), STACK_VARIABLES_PARMS,int stopped)
{
    // ...

    // 调用当前操作系统下的`clone`函数
    if (ARCH_CLONE(fct, STACK_VARIABLES_ARGS, clone_flags, pd, &pd->tid, TLS_VALUE, &pd->tid) == -1)
    {
        // ...
    }

    //...

    return 0;
}

// ...

clone3({flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, child_tid=0x7627b1200990, parent_tid=0x7627b1200990, exit_signal=0, stack=0x7627b0a00000, stack_size=0x7fff80, tls=0x7627b12006c0} => {parent_tid=[6010]}, 88) = 6010

// ...

#define NUM 10

using thread_ptr = std::shared_ptr<ThreadModule::Thread>;

int main()
{
    // 使用哈希表建立线程名称和线程对象的映射
    std::unordered_map<std::string, thread_ptr> threads;

    for (int i = 0; i < NUM; i++)
    {
        thread_ptr t = std::make_shared<ThreadModule::Thread>([]()
                                                              {
        while (true)
        {
            std::cout << "我是新线程" << "，我的线程id为：" << pthread_self() << std::endl;
            sleep(1);
        } });

        threads[t->getName()] = t;
    }

    for (auto pair : threads)
        pair.second->start();

    for (auto pair : threads)
        pair.second->join();

    return 0;
}