实验二-多线程应用程序设计

实验二-多线程应用程序设计

成

绩

信息与通信工程学院实验报告

课程名称：嵌入式系统原理与应用

实验题目：多线程应用程序设计指导教师：

班级：学号：学生姓名：

一、实验目的和任务

1.掌握VI编译环境。

2.掌握GCC编译命令。

3.掌握多个文件共同编译方法。

4.掌握GDB调试命令。

5.了解多线程程序设计的基本原理。

6.学习 pthread 库函数的使用。

二、实验设备

7.硬件：PC机

8.软件：LINUX操作系统、虚拟机

三、实验内容及原理

1.在VI编辑器里编写两个文件（其中一个为主程序，实现显示“hello，linux world，

I am 1405014XXX XXX”，，一个为子程序，实现1~n的乘法），为其书写头文件，共同

编译为可执行文件，执行，观察运行结果。学习书写MAKEFILE文件，编译，执行，观察结果。利用GCC 编译（加参数-g）为可执行文件，利用GDB调试，学习GDB调试命令。

2.编写多线程程序设计。编译并运行，观察结果。（可参照课件或实验指导书）

四、实验步骤或程序流程

1.Gcc编译实验

1)编写实验代码:

图3.1实验主程序

图3.2实验子程序

2)编写Makefile文件：

图3.3 Makefile文件3)Make执行Makefile文件，生成可执行程序并运行：

图3.4 执行

4)Gdb调试运行：

图3.5 gdb调试显示代码

图3.6 gdb调试断点运行

图3.7 gdb调试逐步运行

2.多线程程序设计：

1)对实验代码进行gcc编译：

图3.7gcc编译生成可执行文件2)运行结果：

图3.8程序运行结果

五、实验数据及程序代码

1.Gcc编译实验：

1)主程序：

#include "stdio.h"

#include "my2.h"

int main()

{

p rintf("hello.Linux world.I am 1405014232 zzm\n");

m y2();

}

2)实验子程序:

#include "my2.h"

#include "stdio.h"

void my2()

{

i nt i=1;

float s=1

i nt N;

p rintf("Please input n:\n");

s canf("%d",&N);

f or(i,i<=n,i++)

s*=i;

p rintf("result:");

p rintf("%f",s);

}

3).h头文件：

#ifndef _MY2_H

#define _MY2_H

int main();

void my2();

#endif

4)makefile执行文件：

zzmgo: my2.o my1.o

gcc -o zzmgo my2.o my1.o my1.o: my1.c my2.h

gcc -c my1.c

my2.o:my2.c my2.h

gcc -c my2.c

clean：

r m -rf my1.o my2.o zzmgo

1.多线程程序设计：

#include

#include

#include

#include "pthread.h"

#define

BUFFER_SIZE 16

/* Circular buffer of integers. */

struct prodcons {

int buffer[BUFFER_SIZE];

/* the actual data

*/

pthread_mutex_t lock;

/* mutex ensuring exclusive access to buffer */

int readpos, writepos;

/* positions for reading and writing */

pthread_cond_t notempty;

/* signaled when buffer is not empty */ pthread_cond_t notfull;

/* signaled when buffer is not full */ };

/*--------------------------------------------------------* /

/* Initialize a buffer */

void init(struct prodcons * b)

{

pthread_mutex_init(&b ->lock, NULL);

pthread_cond_init(&b->notempty, NULL);

pthread_cond_init(&b->notfull, NULL);

b->readpos = 0;

b->writepos = 0;

}

/*--------------------------------------------------------* /

/* Store an integer in the buffer */

void put(struct prodcons * b, int data) {

p thread_mutex_loc k(&b->lock);

/* Wait until buffer is not full */

while

((b->writepos + 1) % BUFFER_SIZE == b->readpos) {

printf("wait for not full\n");

pthread_cond_wait(&b ->notfull, &b->lock);

}

/* Write the data and advance write pointer */

b->buffer[b->writepo s] = data;

b->writepos++;

if

(b->writepos >= BUFFER_SIZE)

b->writepos = 0;

/* Signal that the buffer is now not empty */

pthread_cond_signal( &b->notempty);

p thread_mutex_unl ock(&b->lock);

}

/*--------------------------------------------------------* /

/* Read and remove an integer from the buffer */

int get(struct prodcons * b)

{

int data;

p thread_mutex_loc k(&b->lock);

/* Wait until buffer is not empty */

while

(b->writepos == b->readpos) {

printf("wait for not empty\n");

pthread_cond_wait(&b ->notempty, &b->lock);

}

/* Read the data and advance read pointer */

data = b->buffer[b->readpos] ;

b->readpos++;

if

(b->readpos >= BUFFER_SIZE)

b->readpos = 0;

/* Signal that the buffer is now not full */

pthread_cond_signal( &b->notfull);

pthread_mutex_unlock (&b->lock);

return data;

}

/*--------------------------------------------------------* /

#define OVER (-1)

struct prodcons buffer;

/*--------------------------------------------------------*

/

void * producer(void * data) {

int n;

for (n = 0; n < 1000; n++) {

printf("

put-->%d\n", n);

put(&buffer, n);

}

put(&buffer, OVER);

printf("producer stopped!\n");

return NULL;

}

/*--------------------------------------------------------* /

void * consumer(void * data) {

int d;

while (1) {

d = get(&buffer);

if (d == OVER ) break;

printf(" %d-->get\n", d);

}

printf("consumer stopped!\n");

return NULL;

}

/*------------------------------------

--------------------* /

int main(void)

{

pthread_t th_a, th_b;

void * retval;

init(&buffer);

pthread_create(&th_a, NULL, producer, 0);

pthread_create(&th_b, NULL, consumer, 0);

/* Wait until producer and consumer finish.

*/

pthread_join(th_a,

&retval);

pthread_join(th_b,

&retval);

return 0;

}

六、实验数据分析及处理

1.实验结构流程图：

本实验为著名的生产者－消费者问题模型的实现，主程序中分别启动生产者线程和消费者线程。生产者线程不断顺序地将 0 到 1000 的数字写入共享的循环缓冲区，同时消费者线程不断地从共享的循环缓冲区读取数据。流程图如图所示:

图6.1 生产者-消费者实验源代码结构流程图

2.主要函数分析：

下面我们来看一下，生产者写入缓冲区和消费者从缓冲区读数的具体流程，生产者首先要获得互斥锁，并且判断写指针+1 后是否等于读指针，如果相等则进入等待状态，等候条件变量 notfull；如果不等则向缓冲区中写一个整数，并且设置条件变量为notempty，最后释放互斥锁。消费者线程与生产者线程类似，这里就不再过多介绍了。

流程图如下：

图6.2 生产消费流程图

3.主要的多线程API：

在本程序的代码中大量的使用了线程函数，如pthread_cond_signal、pthread_mutex_init、pthread_mutex_lock 等等，这些函数的作用是什么，在哪里定义的，我们将在下面的内容中为其中比较重要的函数做一些详细的说明。

1)pthread_create 线程创建函数：

int pthread_create (pthread_t * thread_id,__const pthread_attr_t * __attr,

void *(*__start_routine) (void *),void *__restrict

__arg)

线程创建函数第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数thread 不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空

指针，这样将生成默认属性的线程。当创建线程成功时，函数返回 0，若不为 0 则说明创建线程失败，常见的错误返回代码为 EAGAIN 和 EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。

2)pthread_join 函数用来等待一个线程的结束。函数原型为：

int pthread_join (pthread_t __th, void **__thread_return)

第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。

3)pthread_exit 函数：

一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数 pthread_exit 来实现。它的函数原型为：void pthread_exit (void *__retval)

唯一的参数是函数的返回代码，只要pthread_join 中的第二个参数thread_return 不是NULL，这个值将被传递给 thread_return。最后要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join 的线程则返回错误代码 ESRCH。下面我们来介绍有关条件变量的内容。使用互斥锁来可实现线程间数据的共享和通信，互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。

这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线线程间的同步。

七、实验结论与感悟（或讨论）

总结实验。对实验的感受和领悟。对实验中某些问题、现象、方法、数据、结果等等内容的讨论。