labweek12

实验报告

实验内容

线程（2）。

编译运行课件 Lecture14 例程代码：

Algorithms 14-1 ~ 14-7.

比较 pthread 和 clone() 线程实现机制的异同

对 clone() 的 flags 采用不同的配置，设计测试程序讨论其结果

配置包括 COLNE_PARENT, CLONE_VM, CLONE_VFORK, CLONE_FILES, CLONE_SIGHAND, CLONE_NEWIPC, CLONE_THREAD

实验环境

 Ubuntu 20.04.2.0（64位）

实验过程

一. alg.14-1-tls-thread.c

 （一）对代码中不熟悉的内容进行解析：

1. __thread （参考资料）

头文件：#include<pthread.h>

功能： __thread 是 GCC 内置的线程局部存储设施，存取效率可以和全局变量相比。__thread 变量使每一个线程有一份独立实体，各个线程的 __thread 变量值互不干扰。

 （二）运行

该程序使用了 __thread int tlsvar = 0; 这个变量，虽然这个变量定义在全局区域，但是在各个线程中该变量互不干扰。

主线程用 pthread_create 创建了子线程1和2，同时也使线程1和2各自拥有了一个 tlsvar 实体。之后主线程和子线程并行执行，直到主线程执行到 pthread_join，等待子线程结束后才能继续执行。

从运行图中就可以看到，每个线程（包括主线程）的 tlsvar 都是从0到4，不会相互干扰。

二. alg.14-2-tls-pthread-key-1.c

 （一）对代码中不熟悉的内容进行解析：

1. pthread_key_create() （参考资料）

头文件：#include<pthread.h>

函数原型：int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));

函数功能： 函数 pthread_key_create() 用来创建线程私有数据。该函数从 TSD 池中分配一项，将其地址值赋给 key 供以后访问使用。第 2 个参数是一个销毁函数，它是可选的，可以为 NULL，为 NULL 时，则系统调用默认的销毁函数进行相关的数据注销。如果不为空，则在线程退出时(调用 pthread_exit() 函数)时将以 key 所关联的数据作为参数调用它，以释放分配的缓冲区，或是关闭文件流等。

不论哪个线程调用了 pthread_key_create()，所创建的 key 都是所有线程可以访问的，但各个线程可以根据自己的需要往 key 中填入不同的值，相当于提供了一个同名而不同值的全局变量(这个全局变量相对于拥有这个变量的线程来说)。

参数：

key：指向一个键值的指针

(destructor)(void)：指明了一个destructor函数，如果这个参数不为空，那么当每个线程退出时(调用 pthread_exit() 函数)时将以 key 所关联的数据作为参数调用它，以释放分配的缓冲区，或是关闭文件流等。

2. pthread_key_delete() （参考资料）

头文件：#include<pthread.h>

函数原型：int pthread_key_delete(pthread_key_t key);

函数功能： 注销一个TSD，这个函数并不检查当前是否有线程正使用该TSD，也不会调用清理函数（destr_function），而只是将TSD释放以供下一次调用pthread_key_create()使用。

参数：

key：指向一个键值的指针

3. pthread_setspecific() （参考资料）

头文件：#include<pthread.h>

函数原型：int pthread_setspecific(pthread_key_t key, const void *value);

函数功能： 为指定线程特定数据键设置线程特定绑定

参数：

key：需要关联的键

value：指向需要关联的数据

返回值： 返回0，表示函数成功。失败时返回一个错误代码。

4. pthread_getspecific() （参考资料）

头文件：#include<pthread.h>

函数原型：void *pthread_getspecific(pthread_key_t key);

函数功能： 获取调用线程的键绑定，并将该绑定存储在value指向的位置中

参数：

key：需要获取数据的键

返回值： 不返回任何错误。

 （二）运行

首先，新建一个命名为 log 的文件夹，此时文件夹为空：

运行程序：

程序先使用 pthread_key_create(&log_key, &close_log_file); 创建私有全局变量 log_key，同时指明每个线程结束时要执行的 destructor 函数。

之后主线程创建5个子线程（然后等待所有子线程结束），每个子线程都执行 thread_worker 函数，每个线程都打开log文件夹中的一个文件（如果没有该文件，就创建文件并打开），然后把打开的文件指针绑定到该线程私有的 log_key 上。

每个线程在各自执行 void write_log(const char *msg) 函数时，把绑定在各自 log_key 中的文件指针通过 pthread_getspecific(log_key) 赋给 fp_log 中，然后对该文件指针指向的文件进行写操作。

等子线程全部结束后，通过 pthread_key_delete(log_key); 将分配的 TSD 注销。

创建了5个文件如下：

文件中内容如下：

三. alg.14-3-tls-pthread-key-2.c

 （一）运行

可以看到，虽然两个子线程都用了 tls_key 来绑定各自的结构体变量，但是他们各自执行，互不干扰，在各自的内存区域使用各自的 tls_key，输出的结构也与预想中的一致。

四. alg.14-4-tls-pthread-key-3.c

 （一）运行

虽然在线程1和线程2中调用了同一个函数 void print_msg(void)，但是他们的 tls_key 和函数是不同的，有他们各自的副本，所以不会产生互相干扰的情况。

五. alg.14-5-tls-pthread-key-4.c

 （一）运行

该程序只创建一个子线程，因此只有一个 tls_key 子副本。

在子线程函数中，先运行 thread_data1(); 函数。在这个函数中，虽然 pthread_setspecific(tls_key, ptr); 进行了绑定，但是由于 ptr 没有申请内存，ptr 存在于线程栈中，在函数返回时，线程的栈空间会被释放，导致 tls_key 中的数据丢失。所以可以看到，程序运行输出的是乱码。

而在 thread_data2(); 函数中，由于 ptr = (struct msg_struct *)malloc(5*sizeof(struct msg_struct)); 申请了内存空间，故 ptr 存在于进程堆中，且在函数最后没有 free，所以 tls_key 中绑定的数据没有丢失，成功输出。但是在子线程函数中要 free 申请的内存空间。

六. alg.14-6-clone-demo.c

 （一）对代码中不熟悉的内容进行解析：

1. clone() （参考资料）

函数原型：int clone(int (*fn)(void *), void *child_stack, int flags, void *arg);

函数功能： 复制进程的系统调用，可以指定父进程与子进程共享哪些资源

参数：

fn: 函数指针，就是指向程序的指针

child_stack: 为子进程分配系统堆栈空间（在linux下系统堆栈空间是2页面，就是8K的内存）

flags: 标志，用来描述子进程需要从父进程继承哪些资源

 CLONE_PARENT: 创建的子进程的父进程是调用者的父进程，新进程与创建它的进程成了“兄弟”而不是“父子”

 CLONE_FS: 子进程与父进程共享相同的文件系统，包括root、当前目录、umask

 CLONE_FILES: 子进程与父进程共享相同的文件描述符（file descriptor）表

 CLONE_NEWNS: 在新的namespace启动子进程，namespace描述了进程的文件hierarchy
 
 CLONE_NEWIPC: 在新的IPC namespace中创建进程

 CLONE_SIGHAND: 子进程与父进程共享相同的信号处理（signal handler）表

 CLONE_PTRACE: 若父进程被trace，子进程也被trace

 CLONE_VFORK: 父进程被挂起，直至子进程释放虚拟内存资源

 CLONE_VM: 子进程与父进程运行于相同的内存空间

 CLONE_PID: 子进程在创建时PID与父进程一致

 CLONE_THREAD: Linux 2.4中增加以支持POSIX线程标准，子进程与父进程共享相同的线程群

arg: 传给子进程的参数

返回值： 成功返回一个标识符。失败时返回-1。

 （二）运行

1. flags = 0:
   
   在该程序中，创建的子进程拥有自己的内存资源，且在父进程到达 if(waitpid(-1, &status, 0) == -1) 之前三个进程同时运行。子进程是在自己的资源内对传入的文本进行操作，不会改变父进程的文本信息。

2. flags = CLONE_VM:
   

在该程序中，创建的两个子进程与父进程共用同一块内存空间，且三者同时运行，所以每个进程对 buf 文本的操作都会影响到其他进程，buf 存储的是最后更改的内容。如上两张图，第一张是子进程2最后更改，所以输出的是子进程2设置的内容；第二张是子进程1最后更改，所以输出的是子进程1设置的内容。

3. flags = CLONE_VM | CLONE_VFORK：
   
   在该程序中，父进程先通过 chdtid1 = clone(child_func1, stack1 + STACK_SIZE, flags | SIGCHLD, buf); 创建子进程1（与父进程共用同一块内存空间），然后父进程被挂起，等待子进程1结束。

子进程1设置了文本内容，然后退出。

父进程继续运行，通过 chdtid2 = clone(child_func2, stack2 + STACK_SIZE, flags | SIGCHLD, buf); 创建子进程2（与父进程共用同一块内存空间），然后父进程被挂起，等待子进程2结束。

子进程2读到的文本内容是子进程1设置后的内容，然后设置子进程2再设置文本内容，退出。

父进程继续运行，可以看到 parent waiting ... 是在子进程2结束后才继续执行的。输出的文本是子进程2设置后的内容。

七. alg.14-7-clone-stack.c

 （一）运行

此程序用来测试线程栈的大小。

八. 比较 pthread 和 clone() 线程实现机制的异同

（参考资料）

1. 异：

pthread: 对于 pthread_create()，是通过用户线程的线程库 pthread 来创建用户线程，由线程库调度。此时内核是感知不到用户线程的存在的。

clone(): clone()创建的是一个 LWP（轻量级进程），因此对内核而言，内核是可感知的，并且由内核所调度。

2. 同：

由于 Linux 本身并没有线程进程的区分，而采用 task 任务一词，所以一般在 Linux 系统下的 pthread_create()，实际上可以看做是 clone() 的调用加上标志的设置，开辟了寄存器空间、栈空间、以及私有存储空间。

九. 对 clone() 的 flags 采用不同的配置，设计测试程序讨论其结果

源代码模板：

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sched.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/syscall.h>
#include <unistd.h>
#define gettid() syscall(__NR_gettid)
  /* wrap the system call syscall(__NR_gettid), __NR_gettid = 224 */
#define gettidv2() syscall(SYS_gettid) /* a traditional wrapper */

#define STACK_SIZE 1024*1024 /* 1Mib. question: what is the upperbound of STACK_SIZE */

static int child_func1(void *arg)
{
    char *chdbuf = (char*)arg; /* type casting */
    printf("child_func1 read buf: %s\n", chdbuf);
    sleep(1);
    sprintf(chdbuf, "I am child_func1, my tid = %ld, pid = %d, ppid = %d", gettid(), getpid(), getppid());
    printf("child_func1 set buf: %s\n", chdbuf);
    sleep(1);
    printf("child_func1 sleeping and then exists ...\n");
    sleep(1);

    return 0;
}

int main(int argc,char **argv)
{
    char *stack1 = malloc(STACK_SIZE*sizeof(char)); /* allocating from heap, safer than stack1[STACK_SIZE] */
    // char *stack2 = malloc(STACK_SIZE*sizeof(char));
    pid_t chdtid1;
    unsigned long flags = 0;
    char buf[100]; /* a global variable has the same behavior */

    if(!stack1) {
        perror("malloc()");
        exit(1);
    }

    flags |= CLONE_PARENT;

    sprintf(buf,"I am parent, my pid = %d, ppid = %d", getpid(), getppid());
    printf("parent set buf: %s\n", buf);
    sleep(1);
    printf("parent clone ...\n");
    
      /* creat child thread, top of child stack is stack+STACK_SIZE */
    chdtid1 = clone(child_func1, stack1 + STACK_SIZE, flags | SIGCHLD, buf); /* what happened if without SIGCHLD */
    if(chdtid1 == -1) {
        perror("clone1()");
        exit(1);
    }

    printf("parent waiting ... \n");

    int status = 0;
    if(waitpid(chdtid1, &status, 0) == -1) { /* wait for any child existing, may leave some child defunct */
        perror("wait()");
    }
  
    sleep(1);

    printf("parent read buf: %s\n", buf);

    system("ps");
    
    free(stack1);
    // free(stack2);
    stack1 = NULL;
    // stack2 = NULL;

    return 0;
}

1. 将 flags 设置为 CLONE_PARENT，运行：
   

可以看到，创建的子进程与父进程的 ppid 相同，他们成为了兄弟，因此父进程的 waitpid(chdtid1, &status, 0) 寻找不到子进程来让他等待，输出等待错误。两个进程各自执行，互不干扰。

2. 将 flags 设置为 CLONE_PARENT | CLONE_VM，运行：
   

可以看到，创建的子进程与父进程的 ppid 相同，且他们共享一个内存空间。

3. 将 flags 设置为 CLONE_PARENT | CLONE_VFORK，运行：
   
   可以看到，虽然父子进程成为了兄弟进程，但是父进程在创建完子进程后就会被挂起，直到子进程释放虚拟内存资源后才会继续运行（尽管 wait() 寻找不到创建的子进程）。

4. 将 flags 设置为 CLONE_FILES，运行：
   
   可以看到父子进程共用一个文件描述符表。

5. 将 flags 设置为 CLONE_VM | CLONE_SIGHAND，运行：
   

6. 将 flags 设置为 CLONE_NEWIPC，运行：
   
   无法 clone。

7. 将 flags 设置为 CLONE_NEWIPC，运行：
   
   无法 clone。