《Linux程序设计》实验8 线程程序设计
一、实验目的
1．掌握LINUX下线程和进程的概念
2．理解多线程程序的基本原理
3．了解PTHREAD库
4．学会使用PTHREAD库中的函数编写多线程程序
二、实验任务与要求
1．熟悉新线程的创建，以及和主线程之间的关系
2．掌握线程之间的通信和共享变量
3．了解并学会使用互斥锁
4．编写一个生产者-消费者程序
5．用多种方法实现线程之间的同步
三、实验工具与准备
计算机PC机，Ubuntu操作系统
四、实验内容与实验步骤
任务1.调试下列程序。
程序中使用pthread线程库创建一个新线程，在父进程（也可以称为主线程）和新线程中分别显示进程id和线程id，并观察线程id数值。
程序代码如下：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h> /*pthread_create()函数的头文件*/
#include <unistd.h>pthread_t ntid;
void printids(const char *s) /*各线程共享的函数*/
{pid_t pid;pthread_t tid;pid = getpid();tid = pthread_self();printf("%s pid= %u tid= %u (0x%x)\n", s, (unsigned int)pid, (unsigned int)tid, (unsigned int)tid);
}void *thread_fun(void *arg) /*新线程执行代码*/
{printids(arg);return NULL;
}int main(void)
{int err;
/*下列函数创建线程*/err = pthread_create(&ntid, NULL, thread_fun, "我是新线程: ");if (err != 0) {fprintf(stderr, "创建线程失败: %s\n", strerror(err));exit(1);}printids("我是父进程:");sleep(2); /*挂起2秒，等待新线程运行结束*/return 0;
}
问题
（1）进程在一个全局变量ntid中保存了新创建的线程的id，如果新创建的线程不调用pthread_self而是直接打印这个ntid，能不能达到同样的效果？
（2）在本题中，如果没有sleep(2)函数，会出现什么结果？
任务2．Fibonacci（斐波那契数列）
为：1，1，2，3，5，8，……，通常，Fibonacci数列可表达为
Fib1 = 1
Fib2 = 1
Fibn = fibn-1 + fibn-2
编写一个多线程程序来生成Fibonacci。程序应该这样工作：用户运行程序时在命令行输入要产生Fibonacci数列的数，然后程序创建一个新的线程来产生Fibonacci数，把这个序列放到线程共享的数据中（数组可能是一种最方便的数据结构）。当线程执行完成后，父线程将输出由子线程产生的序列。由于在子线程结束前，父线程不能开始输出Fibonacci数列，因此父线程必须等待子线程的结束。
任务3 调试下列程序。程序只是给出线程产生、退出和等待的程序。
程序代码如下：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h> /*pthread_create函数的头文件*/
#include <unistd.h>
void * thread_fun1(void *arg)
{printf("thread 1 returning\n");return((void *)1);
}void * thread_fun2(void *arg)
{printf("thread 2 exiting\n");pthread_exit((void *)2);
}int main(void)
{Int err;pthread_t tid1, tid2;void * tret;err = pthread_create(&tid1, NULL, thread_fun1, NULL); /*创建第1个线程*/if (err != 0)fprintf(stderr,"can't create thread 1: %s\n", strerror(err));err = pthread_create(&tid2, NULL, thread_fun2, NULL); /*创建第2个线程*/if (err != 0)fprintf(stderr,"can't create thread 2: %s\n", strerror(err));err = pthread_join(tid1, &tret); /*等待第1个线程结束*/if (err != 0)fprintf(stderr,"can't join with thread 1: %s\n", strerror(err));printf("thread 1 exit code %d\n", (int)tret);err = pthread_join(tid2, &tret); /*等待第2个线程结束*/if (err != 0)fprintf(stderr,"can't join with thread 2: %s\n", strerror(err));printf("thread 2 exit code %d\n", (int)tret);exit(0); /* 现在可以安全地返回了 */
}
问题
（1）修改程序，在线程1、线程2中完成一些任务，例如各自做1到1000的加法，有明显的时间跨度，观察线程的执行情况与线程结束时的状态；
（2）改变线程1、2执行任务的时间，观察结果。
任务4.调试下列程序。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>pthread_mutex_t mutex; /*定义互斥锁*/
int lock_var; /*两个线程都能修改的共享变量，访问改变量必须互斥*/
void pthread1(void *arg);
void pthread2(void *arg);
int main(int argc, char *argv[])
{pthread_t id1,id2;int ret;pthread_mutex_init(&mutex,NULL); /*互斥锁初始化*/ret=pthread_create(&id1,NULL,(void *)pthread1, NULL); /*创建第1个线程*/if(ret!=0)printf("pthread cread1\n");ret=pthread_create(&id2,NULL,(void *)pthread2, NULL); /*创建第2个线程*/if(ret!=0)printf ("pthread cread2\n");pthread_join(id1,NULL); /*等待第1个线程结束*/pthread_join(id2,NULL); /*等待第2个线程结束*/pthread_mutex_destroy(&mutex); /*释放mutex资源*/exit(0);
}void pthread1(void *arg) /*第1个线程执行代码*/
{int i;for(i=0;i<2;i++){pthread_mutex_lock(&mutex); /*锁定临界区*//*临界区*/lock_var++;
printf("pthread1：第%d次循环，第1次打印 lock_var=%d\n",i,lock_var);sleep(1);
printf("pthread1：第%d次循环，第2次打印 lock_var=%d\n",i,lock_var);
/* 已经完成了临界区的处理，解除对临界区的锁定。*/pthread_mutex_unlock(&mutex); /*解锁 */
sleep(1);}
}void pthread2(void *arg) /*第2个线程执行代码*/
{int i;for(i=0;i<5;i++){pthread_mutex_lock(&mutex); /*锁定临界区*//*临界区*/sleep(1);lock_var++;
printf("pthread2：第%d次循环 lock_var=%d\n",i,lock_var);/* 已经完成了临界区的处理，解除对临界区的锁定。*/pthread_mutex_unlock(&mutex); /*解锁 */sleep(1);}
}
问题：
（1）把程序pthread1、pthread2中所有的pthread_mutex_lock(&mutex)和pthread_mutex_unlock(&mutex)代码除去，也就是不对访问共享变量lock_var进行互斥。编译并运行程序，观察pthread1同一次循环的第1次打印和第2次打印的结果是否相同？如果在应用程序中产生这样的情况，会发生什么后果？
（2）修改程序，如果在程序中省略语句sleep(2);对程序运行结果有什么影响？
任务5．调试程序，程序的功能演示了一个生产者-消费者的例子，生产者生产的产品一个结构体串在链表的表头上，消费者从表头取走结构体。
#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>struct msg {struct msg *next;int num;
};struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER; /*条件变量置初值*/
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; /*互斥锁置初值*/void *producer(void *p) //生产者线程代码
{struct msg *mp;
int i;for (i=0;i<20;++i) {mp = malloc(sizeof(struct msg));mp->num = rand() % 1000 + 1;printf("Produce %d\n", mp->num);pthread_mutex_lock(&lock);mp->next = head;head = mp;pthread_mutex_unlock(&lock);pthread_cond_signal(&has_product); //唤醒消费者线程sleep(rand() % 5);}
}void *consumer(void *p) //消费者线程代码
{struct msg *mp;int i;for (i=0;i<20;++i) {pthread_mutex_lock(&lock);while (head == NULL) pthread_cond_wait(&has_product, &lock); mp = head;head = mp->next;pthread_mutex_unlock(&lock);printf("Consume %d\n", mp->num);free(mp);sleep(rand() % 5);}
}int main(int argc, char *argv[])
{pthread_t pt, ct; srand(time(NULL));pthread_create(&pt, NULL, producer, NULL);pthread_create(&ct, NULL, consumer, NULL);pthread_join(pt, NULL);pthread_join(ct, NULL);return 0;
}
问题
（1）调试此程序，画出此程序的通信机制；
（2）修改此程序，把此程序的框架应用到实际当中。
五、实验结果记录
任务1.调试下列程序
（1）进程在一个全局变量ntid中保存了新创建的线程的id，如果新创建的线程不调用pthread_self而是直接打印这个ntid，能不能达到同样的效果？
在给定的程序中，不能通过直接打印全局变量 ntid 来达到与在新线程中调用 pthread_self 相同的效果。 因为：
1.数据类型差异： pthread_t 类型（也就是 ntid 的类型）在不同的系统上可能有不同的实现方式。它可能是一个结构体或者是一个整数类型的别名等。 当使用 pthread_self 函数时，它返回的是当前线程的一个唯一标识符，并且这个返回值是经过系统内部处理以适配具体平台实现的，其格式是符合线程库对线程标识的定义的。 而直接打印 ntid ，只是简单地输出了一个未经处理的、可能与实际用于标识线程的内部格式不完全匹配的值。例如，在某些系统上， pthread_t 可能是一个结构体，直接打印结构体变量可能不会按照预期输出线程的有效标识信息。
2.线程创建过程中的赋值特性： 在程序中， ntid 是通过 pthread_create 函数的参数传递方式来获取新线程的标识符的。这个赋值过程是由线程库内部机制完成的，它将新创建线程的标识符正确地赋给了 ntid 。这并不意味着 ntid 就可以直接等同于新线程内部通过 pthread_self 获取到的线程标识符。 pthread_self 获取的是线程在运行时自身确切的、经过系统完整处理的标识，而 ntid 只是在创建线程时外部对新线程标识符的一种记录方式，两者的获取途径和含义存在本质区别。
（2）在本题中，如果没有 sleep(2)函数，会出现什么结果？
如果没有 sleep(2) 函数，可能会出现主线程（父进程）先于新创建的线程执行完毕并退出的情况，导致程序的执行结果不符合预期，甚至可能引发一些不确定的行为:
1.线程执行顺序的不确定性： 在多线程编程中，线程的执行顺序是不确定的。当主线程创建新线程后，新线程和主线程是并发执行的，它们之间的执行先后顺序取决于操作系统的调度策略。 没有 sleep(2) 函数时，主线程在创建新线程后会继续向下执行 return 0 语句，这可能导致主线程迅速结束其生命周期。而新线程可能还未来得及执行 printids 函数来输出其线程相关信息，主线程就已经退出了。
2.程序资源释放与异常情况： 当主线程退出时，整个进程可能会随之结束（取决于具体的程序设置和操作系统行为）。这可能导致新线程还在执行过程中就被强制终止，新线程所占用的资源可能无法得到正常的清理和释放，从而可能引发一些资源泄漏或者其他未定义的行为。 例如，如果新线程在后续的执行中有对一些共享资源（如打开的文件、动态分配的内存等）进行操作，由于主线程提前结束进程，这些资源可能无法按照正确的流程进行关闭或释放，进而影响系统的稳定性和程序的正确性。 所以， sleep(2) 函数在这里起到了让主线程暂停一段时间的作用，以确保新线程有足够的时间完成其应该执行的操作，使得程序的执行结果能够按照预期展示线程相关的信息。
任务二：编写一个多线程程序来生成Fibonacci
任务3 调试下列程序
问题
（1）修改程序，在线程 1、线程 2中完成一些任务，例如各自做 1到 1000的加法，有明显的时间跨度，观察线程的执行情况与线程结束时的状态；
（2）改变线程 1、2执行任务的时间，观察结果。
任务 4.调试下列程序。
（1）把程序 pthread1、pthread2中所有的 pthread_mutex_lock(&mutex)和pthread_mutex_unlock(&mutex)代码除去，也就是不对访问共享变量 lock_var进行互斥。编译并运行程序，观察 pthread1同一次循环的第 1次打印和第 2次打印的结果是否相同？如果在应用程序中产生这样的情况，会发生什么后果？
pthread1同一次循环的第 1 次打印和第 2 次打印的结果很可能不相同。这是因为两个线程 pthread1和 pthread2都可以同时访问和修改共享变量 lock_var，在没有互斥机制的情况下，它们的执行顺序是不确定的，可能会出现交叉访问和修改lock_var的情况。
在应用程序中产生这样情况的后果：
1.数据不一致性：共享变量的值可能会出现不符合预期的结果。比如在一个银行账户余额管理的应用程序中，如果多个线程同时对账户余额（类似这里的共享变量 lock_var）进行操作，没有互斥控制的话，可能会导致余额计算错误，出现重复扣除或重复增加等情况，使得账户余额数据不准确。
2.程序逻辑混乱：程序的后续逻辑可能会基于错误的共享变量值进行判断和执行，进而导致整个程序的运行出现错误。例如，根据共享变量的值来决定是否执行某个重要操作，若共享变量值因并发访问错误而不准确，那么这个决定可能就是错误的，从而引发一系列后续错误行为，如不该执行的操作执行了，该执行的操作没执行等。
3.难以调试：当出现问题时，由于多个线程并发修改共享变量且没有互斥控制，很难准确追踪到是哪个线程在什么时刻对共享变量进行了何种操作导致的错误，使得调试程序变得极为困难。
（2）修改程序，如果在程序中省略语句 sleep(2);对程序运行结果有什么影响？
1.输出顺序方面： 在原程序中有 sleep(1); 语句时：线程在每次对共享变量进行操作前后或者在循环过程中会睡眠一段时间，这使得线程之间有一定的时间间隔来交替执行。 当省略 sleep(1); 语句后：两个线程会尽可能快地连续执行各自的循环体内容。这可能导致输出结果在控制台快速滚动，输出顺序变得难以预测且很可能是混乱的。
2.共享变量 lock_var 的值变化方面： 在原程序中有 sleep(1); 语句时：由于线程在每次对共享变量进行操作前后都有睡眠，这在一定程度上减缓了两个线程对共享变量的并发访问速度。使得每个线程在修改 lock_var 时，相对更有可能是基于前一个线程修改后的稳定值进行操作。当省略 sleep(1); 语句后：两个线程会快速地并发访问和修改共享变量 lock_var。这就大大增加了出现数据不一致或不符合预期结果的风险。
3.程序整体执行速度的感知方面： 在原程序中有 sleep(1); 语句时：由于线程在循环过程中频繁睡眠，整个程序的执行看起来会比较缓慢，从开始执行到全部结束会花费相对较多的时间，因为大量时间花费在睡眠等待上。 当省略 sleep(1); 语句后：程序会尽可能快地执行完两个线程的所有循环操作，整体执行速度在感觉上会明显加快，会更快地完成对共享变量的所有操作并结束程序运行，但同时如前面所述，也伴随着输出混乱和共享变量值可能不正确的风险。
任务5．调试程序
问题
（1）调试此程序，画出此程序的通信机制；
（2）修改此程序，把此程序的框架应用到实际当中。
六、实验结果分析
1. 线程创建（pthread_create()函数）：
函数原型：int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
参数说明：
thread：是一个指向pthread_t类型的指针，用于存储新创建线程的标识符。
attr：是一个指向pthread_attr_t类型的指针，用于指定新线程的属性，如果设置为NULL，则使用默认属性。
start_routine：是一个函数指针，指向新线程要执行的函数。这个函数的返回值类型为void *，参数类型也为void *。
arg：是传递给新线程要执行函数的参数，类型为void *，如果不需要传递参数，可以设置为NULL。
2. 主线程与新线程的关系：
主线程是程序启动时自动创建的线程，它负责执行程序的主要逻辑，如初始化工作、创建其他子线程等。
新线程是由主线程通过pthread_create()函数创建的，它们共享所属进程的地址空间。新线程在创建后会按照指定的函数进行独立执行，但它们的执行顺序是由操作系统调度决定的。
主线程可以通过pthread_join()函数等待新线程结束，这样可以确保主线程在新线程完成任务之前不会提前退出，从而保证新线程能够正常完成其任务。
3.共享变量：
由于线程共享进程的地址空间，所以可以直接定义全局变量或者在堆上分配内存来作为共享变量，供多个线程访问和操作。
4. 线程间通信问题及注意事项：
虽然线程可以共享变量，但在对共享变量进行操作时，如果没有适当的同步机制，可能会导致数据不一致的问题。例如，在上面的示例中，如果两个线程同时对shared_variable进行修改，可能会出现结果不符合预期的情况。
为了解决这个问题，需要采用线程同步机制，如互斥锁等，来确保在同一时刻只有一个线程能够对共享变量进行操作。
5. 互斥锁的作用：
互斥锁（pthread_mutex_t）是一种用于控制线程对共享资源访问顺序的同步机制。它的作用是确保在同一时刻只有一个线程能够获取锁并访问被锁定的共享资源，其他线程如果想要访问该资源，必须等待锁被释放。
6. 互斥锁相关函数：
初始化函数（pthread_mutex_init()）：
函数原型：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
参数说明：
mutex：是一个指向pthread_mutex_t类型的指针，用于存储要初始化的互斥锁。
attr：是一个指向pthread_mutexattr_t类型的指针，用于指定互斥锁的属性，如果设置为NULL，则使用默认属性。
7. 加锁函数（pthread_mutex_lock()）：
函数原型：int pthread_mutex_lock(pthread_mutex_t *mutex);
参数说明：
mutex：是一个指向pthread_mutex_t类型的指针，指向要加锁的互斥锁。
8. 解锁函数（pthread_mutex_unlock()）：
函数原型：int pthread_mutex_unlock(pthread_mutex_t *mutex);
参数说明：
mutex：是一个指向pthread_mutex_t类型的指针，指向要解锁的互斥锁。
七、实验心得
通过本次实验，我对以下内容有了更深一步的了解：
一、Linux 下线程和进程的概念
（一）进程
进程是程序在计算机中的一次执行过程，它是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。
进程拥有自己独立的地址空间，包括代码段、数据段、堆栈段等。不同进程之间的地址空间是相互隔离的，这意味着一个进程通常无法直接访问另一个进程的内存空间。
进程是操作系统进行资源分配和调度的基本单位，例如，操作系统会为每个进程分配 CPU 时间片、内存等资源。
（二）线程
线程是进程中的一个执行流，一个进程可以包含多个线程。线程是进程内部的一个相对独立的执行路径，它共享所属进程的地址空间（包括代码段、数据段、堆等）。
线程不像进程那样拥有完全独立的资源，它与同一进程中的其他线程共享许多资源，如文件描述符、全局变量等。但每个线程也有自己独立的栈空间，用于存储局部变量、函数调用信息等。
线程是 CPU 调度的基本单位，操作系统通过调度线程来实现多任务处理，提高程序的执行效率。
二、多线程程序的基本原理
多线程程序允许多个线程并发执行，从而充分利用多核 CPU 的计算能力，提高程序的整体性能。其基本原理如下：
当一个多线程程序启动时，首先会创建一个主线程，主线程负责执行程序的主要逻辑。然后，可以根据需要在主线程中创建多个子线程。
这些线程在操作系统的调度下，轮流获得 CPU 时间片，在各自的时间片内执行自己的任务。由于线程共享进程的地址空间，它们可以方便地访问和操作共享的数据。
线程之间的执行顺序是不确定的，由操作系统的线程调度器根据系统的负载、线程的优先级等因素来决定哪个线程何时获得 CPU 时间片进行执行。
三、PTHREAD 库
PTHREAD 库（POSIX Threads Library）是一个用于在类 UNIX 操作系统（包括 Linux）上进行多线程编程的标准库。它提供了一系列函数来创建、管理和同步线程。
优点：
它提供了统一的线程编程接口，使得在不同的类 UNIX 系统上编写多线程程序具有较好的可移植性。
涵盖了线程创建、销毁、等待、同步等多方面的功能，功能较为完备。
常用函数类型及示例（后续会详细讲解具体函数使用）：
线程创建函数：用于创建新的线程，如pthread_create()。
线程等待函数：用于等待一个线程结束，如pthread_join()。
线程同步相关函数：如互斥锁相关函数（pthread_mutex_init()、pthread_mutex_lock()、pthread_mutex_unlock()等）用于控制线程对共享资源的访问顺序，避免冲突。