当前位置：首页 > news >正文

实验二多线程编程实验

news 来源：原创 2025/7/13 5:40:41

一、实验目的

1、掌握线程的概念，明确线程和进程的区别。

2、学习Linux下线程创建方法及编程。

3、了解线程的应用特点。

4、掌握用锁机制访问临界区实现互斥的方法。

5、掌握用信号量访问临界区实现互斥的方法。

6、掌握线程下用信号量实现同步操作的方法。

二、实验内容

1、运行下列程序，给出执行结果，并分析运行结果。（3分）

1） #include <stdio.h>

#include <pthread.h>

#include <unistd.h>

// 打印函数（在屏幕上显示字符串）

void printer(char *str){

while(*str!='\0')

{ putchar(*str);

fflush(stdout);

str++;

sleep(1);

}

printf("\n");

}

// 线程一

void *thread_fun_1(void *arg)

{

char *str = "hello";

printer(str); //调用打印函数

}

// 线程二

void *thread_fun_2(void *arg)

{

char *str = "world";

printer(str); //调用打印函数

}

int main(void)

{

pthread_t tid1, tid2;

// 创建 2 个线程

pthread_create(&tid1, NULL, thread_fun_1, NULL);

pthread_create(&tid2, NULL, thread_fun_2, NULL);

// 等待线程结束，回收其资源

pthread_join(tid1, NULL);

pthread_join(tid2, NULL);

return 0;

}

编译及执行过程和运行结果截屏：

结果分析：

线程一和线程二，它们分别打印"hello"和"world"字符串。主线程使用pthread_join函数等待两个线程结束。

由于并发执行的原因，线程一和线程二的打印操作会交替进行，输出的结果可能是"howorldello"、"howerlllod"等不确定的顺序。

每个字符之间有1秒的延迟，所以输出的结果中每个字符之间会有间隔。最后输出一个换行符，每次执行的结果都会在新的一行显示。

#include <stdio.h>

#include <pthread.h>

#include <unistd.h>

pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//定义并初始化锁

//打印函数（在屏幕上显示字符串）

void printer(char *str)

{

pthread_mutex_lock(&mutex_x);//上锁

while(*str!='\0')

{

putchar(*str);

fflush(stdout);

str++;

sleep(1);

}

printf("\n");

pthread_mutex_unlock(&mutex_x);//解锁

}

// 线程一

void *thread_fun_1(void *arg)

{

char *str = "hello";

printer(str); //调用打印函数

}

// 线程二

void *thread_fun_2(void *arg)

{

char *str = "world";

printer(str); //调用打印函数

}

int main(void)

{

pthread_t tid1, tid2;

// 创建 2 个线程

pthread_create(&tid1, NULL, thread_fun_1, NULL);

pthread_create(&tid2, NULL, thread_fun_2, NULL);

// 等待线程结束，回收其资源

pthread_join(tid1, NULL);

pthread_join(tid2, NULL);

pthread_mutex_destroy(&mutex_x); //销毁互斥锁

return 0;

}

编译及执行过程和运行结果截屏：

结果分析：

在程序中创建了两个线程，分别执行thread_fun_1和thread_fun_2函数。这两个函数都调用了printer函数，每次调用时都会上锁mutex_x，然后通过putchar函数逐个打印字符串中的字符，并休眠1秒钟。

由于两个线程同时运行，打印函数的执行是交替进行的。线程一先执行，打印"hello"，然后释放锁，线程二获取到锁，打印"world"，最后两个线程结束。

所以最终的输出结果为"hello world"。

#include <stdio.h>

#include <pthread.h>

#include <unistd.h>

#include <semaphore.h>

sem_t semA; //声明一个名为semA的信号量变量

//打印函数（在屏幕上显示字符串）

void printer(char *str)

{

sem_wait(&semA);//申请信号量（P操作）

while(*str!='\0')

{

putchar(*str);

fflush(stdout);

str++;

sleep(1);

}

printf("\n");

sem_post(&semA);//释放信号量（V操作）

}

// 线程一

void *thread_fun_1(void *arg)

{

char *str = "hello";

printer(str); //调用打印函数}

// 线程二

void *thread_fun_2(void *arg)

{

char *str = "world";

printer(str); //调用打印函数}

int main(void)

{

pthread_t tid1, tid2;

if(sem_init(&semA, 0, 1)) //初始化信号量的值为1（二元信号量）

printf("error sem_init!\n");

// 创建 2 个线程

pthread_create(&tid1, NULL, thread_fun_1, NULL);

pthread_create(&tid2, NULL, thread_fun_2, NULL);

// 等待线程结束，回收其资源

pthread_join(tid1, NULL);

pthread_join(tid2, NULL);

sem_destroy(&semA); //销毁信号量

return 0;

}

编译及执行过程和运行结果截屏：

结果分析：

在主函数中，创建了两个线程，分别调用了thread_fun_1和thread_fun_2函数。这两个函数内部调用了printer函数。由于两个线程同时调用printer函数，但是通过信号量的控制，确保了只有一个线程可以打印字符，另一个线程在sem_wait(&semA)处等待。因此，打印的结果是"helloworld"。

2、通过多线程模拟多窗口售票,在主线程下创建4个子线程，模拟4个售票窗口，假设有20张票待售，运行该程序看会有什么样的结果，分析程序和执行结果。（1分）

<参考程序>

#include<pthread.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<unistd.h>

#include<semaphore.h>

#include<stdint.h>

int ticket_sum=20;

void *sell_ticket(void *arg)

{

int i;

for(i=0;i<20;i++)

{

if(ticket_sum>0)

{

sleep(1);

printf("sell the %dth\n",20-ticket_sum+1);

ticket_sum--;

}

return 0;

}

int main()

{

int flag,i;

pthread_t tids[4];

for(i=0;i<4;i++)

{

flag=pthread_create(&tids[i],NULL,&sell_ticket,NULL);//创建线程

if(flag)

{

printf("pthread create error ,flag=%d",flag);

return flag;

}

sleep(20);

void *ans;

for(i=0;i<4;i++)

{

flag=pthread_join(tids[i],&ans);//等待线程结束

if(flag)

{

printf("tid=%lu,join erro flag=%d",tids[i],flag);

return flag;

}

printf("ans=%ld\n",(intptr_t)ans);

}

return 0;

}给出编译及执行过程和运行结果：（部分截屏）

结果分析：

该程序创建了4个线程，每个线程都执行sell_ticket函数。在sell_ticket函数中，使用一个循环进行售票操作，每次售票后ticket_sum减1，直到ticket_sum为0结束循环。

在主函数中，创建4个线程，并等待线程完成。等待线程完成后，打印线程的返回值，此处返回值为0。

3、修改上题，用锁机制实现线程互斥进入临界区，解决售票窗口超卖问题。要求给出编译及运行过程和结果截图。（2分）

#include <stdio.h>

#include <pthread.h>

#include <unistd.h>

#include<semaphore.h>

#include<stdint.h>

int ticket_sum = 20; // 总票数

pthread_mutex_t mutex; // 定义互斥锁

void *sell_ticket(void *arg)

{

int ticket_count = 0; // 售出的票数

while (1) {

pthread_mutex_lock(&mutex); // 上锁

if (ticket_sum > 0) {

sleep(1); // 模拟售票耗时

printf("sell the %d th\n", 20 - ticket_sum + 1);

ticket_sum--;

ticket_count++;

} else {

pthread_mutex_unlock(&mutex); // 解锁

break;

}

pthread_mutex_unlock(&mutex); // 解锁

}

pthread_exit((void *)ticket_count); // 返回售出的票数

}

int main()

{

pthread_t tids[4]; // 线程数组

int i;

int ticket_count = 0; // 总共售出的票数

pthread_mutex_init(&mutex, NULL); // 初始化互斥锁

for (i = 0; i < 4; i++) {

pthread_create(&tids[i], NULL, sell_ticket, NULL); // 创建线程

}

for (i = 0; i < 4; i++) {

void *ret;

pthread_join(tids[i], &ret); // 等待线程结束

ticket_count += (intptr_t)ret; // 统计每个线程售出的票数

}

printf("总共售出了 %d 张票\n", ticket_count);

pthread_mutex_destroy(&mutex); // 销毁互斥锁

return 0;

}

给出编译及执行过程和运行结果：（部分截屏）

4、修改实验内容2，用信号量实现线程互斥进入临界区，解决售票窗口超卖问题。要求给出编译及执行过程和结果截屏。（2分）

#include <stdio.h>

#include <pthread.h>

#include <unistd.h>

#include<semaphore.h>

#include<stdint.h>

#define TOTAL_TICKETS 20

int tickets = TOTAL_TICKETS;

sem_t semaphore;

void *sellTicket(void *arg) {

char *sellerName = (char *)arg;

while (1) {

sem_wait(&semaphore); // 获得信号量，进入临界区

if (tickets > 0) {

tickets--;

printf("sell the %dth\n", 20-tickets);

} else {

printf("没有票了\n");

sem_post(&semaphore); // 离开临界区

break;

}

sem_post(&semaphore); // 离开临界区

usleep(100000); // 模拟售票过程的耗时操作

}

return NULL;

}

int main() {

pthread_t sellers[4];

sem_init(&semaphore, 0, 1);

char *sellerNames[4] = {"售票窗口1", "售票窗口2", "售票窗口3", "售票窗口4"};

for (int i=0; i<4; i++) {

pthread_create(&sellers[i], NULL, sellTicket, (void *)sellerNames[i]);

}

for (int i=0; i<4; i++) {

pthread_join(sellers[i], NULL);

}

sem_destroy(&semaphore);

return 0;

}

给出编译及执行过程和运行结果：（部分截屏）

5、利用线程和信号量机制实现司机售票员同步操作问题。（1分）

参考程序框架：

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <pthread.h>

#include <semaphore.h>

sem_t door, stop; // 设置关门和停车两个信号量

void *thread_driver(void *arg) // 司机线程

{

while (1)

{

sem_wait(&door); // P(door)，等待售票员的关门信号

printf("司机: 启动汽车\n");

printf("司机: 驾驶汽车\n");

sleep(1);

printf("司机: 到站停车\n");

sem_post(&stop); // V(stop)，发送停车信号

}

void *thread_conductor(void *arg) // 售票员线程

{

while (1)

{

printf("售票员: 关门\n");

sem_post(&door); // V(door)，发送关门信号

printf("售票员: 卖票\n");

sem_wait(&stop); // P(stop)，等待司机的停车信号

printf("售票员: 开门\n");

printf("乘客上下车\n");

sleep(1);

}

int main()

{

int sg1, sg2;

pthread_t driver, conductor; // 定义两个变量存放线程标识符

sg1 = sem_init(&door, 0, 0); // 初始化关门信号量door，初始值为0

sg2 = sem_init(&stop, 0, 0); // 初始化停车信号量stop，初始值为0

pthread_create(&driver, NULL, (void *)thread_driver, NULL); // 创建司机线程

pthread_create(&conductor, NULL, (void *)thread_conductor, NULL); // 创建售票员线程

pthread_join(driver, NULL); // 等待司机线程结束

pthread_join(conductor, NULL); // 等待售票员线程结束

sem_destroy(&door); // 销毁关门信号量

sem_destroy(&stop); // 销毁停车信号量

return 0;

}

编译及执行过程和结果截屏：

6、利用线程和信号量实现生产者消费者问题（涉及线程同步和互斥问题）。（附加题）

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <pthread.h>

#include <semaphore.h>

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];

sem_t mutex, empty, full;

int in = 0;

int out = 0;

void *producer(void *arg) {

int item;

while (1) {

item = rand() % 100; // 生产一个随机数作为产品

sem_wait(&empty); // 等待空缓冲区

sem_wait(&mutex); // 互斥访问缓冲区

printf("Produced item: %d\n", item);

buffer[in] = item;

in = (in + 1) % BUFFER_SIZE;

sem_post(&mutex); // 释放互斥锁

sem_post(&full); // 增加满缓冲区的信号量

sleep(1); // 生产速度较慢，方便观察

}

void *consumer(void *arg) {

int item;

while (1) {

sem_wait(&full); // 等待满缓冲区

sem_wait(&mutex); // 互斥访问缓冲区

item = buffer[out];

out = (out + 1) % BUFFER_SIZE;

printf("Consumed item: %d\n", item);

sem_post(&mutex); // 释放互斥锁

sem_post(&empty); // 增加空缓冲区的信号量

sleep(1); // 消费速度较慢，方便观察

}

int main() {

pthread_t producer_thread, consumer_thread;

sem_init(&mutex, 0, 1); // 初始化互斥锁

sem_init(&empty, 0, BUFFER_SIZE); // 初始化空缓冲区的信号量

sem_init(&full, 0, 0); // 初始化满缓冲区的信号量

pthread_create(&producer_thread, NULL, producer, NULL);

pthread_create(&consumer_thread, NULL, consumer, NULL);

pthread_join(producer_thread, NULL);

pthread_join(consumer_thread, NULL);

sem_destroy(&mutex); // 销毁互斥锁

sem_destroy(&empty); // 销毁空缓冲区的信号量

sem_destroy(&full); // 销毁满缓冲区的信号量

return 0;

}

编译及执行过程和结果截屏：

三、实验总结和体会

通过这次实验，我对操作系统中多线程编程有了更深入的了解和实践经验。在实验中，我学习了使用多线程编程来实现并发任务的处理，以及线程间的同步和互斥机制。

首先，我学会了使用线程创建函数来创建和启动新线程。我了解到线程是程序中的并发执行流，可以并行处理任务，提高程序的执行效率。在实验中，我通过使用pthread库中的函数，如pthread_create()来创建线程，并指定线程函数进行任务处理。

其次，我学会了使用互斥锁来保护共享资源的访问。在多线程编程中，当多个线程需要同时访问共享资源时，可能会导致竞态条件和数据不一致的问题。为了避免这些问题，我使用了互斥锁来实现线程间的互斥访问。通过使用pthread库中的函数，如pthread_mutex_init()和pthread_mutex_lock()等，我可以对关键代码段进行上锁，使得同一时间只有一个线程可以访问共享资源。

此外，我还学习了使用条件变量来实现线程间的通信和同步。条件变量可以用于线程间的等待和唤醒操作，使得线程可以在特定条件满足时才进行执行。通过使用pthread库中的函数，如pthread_cond_init()和pthread_cond_wait()等，我可以实现线程的等待和唤醒操作，以实现线程间的同步和协作。

通过这次实验，我对操作系统中多线程编程的原理和实践有了更深入的理解。我认识到多线程编程可以提高程序的并发性和效率，但也需要考虑线程间的同步和互斥，以及资源管理和性能优化等方面。我意识到多线程编程的复杂性和挑战，但也体会到了并发编程的用处

相关文章：