基于arm的多线程应用程序设计大学论文.docx
- 文档编号:29091224
- 上传时间:2023-07-20
- 格式:DOCX
- 页数:18
- 大小:136.03KB
基于arm的多线程应用程序设计大学论文.docx
《基于arm的多线程应用程序设计大学论文.docx》由会员分享,可在线阅读,更多相关《基于arm的多线程应用程序设计大学论文.docx(18页珍藏版)》请在冰豆网上搜索。
基于arm的多线程应用程序设计大学论文
开放性实验报告
题目:
基于ARM的多线程应用程序设计
院系名称:
电气工程学院
专业班级:
自动1302
学生姓名:
学号:
指导教师:
成绩:
指导老师签名:
日期:
2017.1.6
目录
1系统概况1
2完成步骤1
2.1思路分析1
2.2结构流程图2
2.3重要函数3
2.3.1源程序3
2.3.2函数分析9
3实验数据12
3.1下载和调试截图12
4结果分析和总结12
设计心得15
参考文献16
1系统概况
生产者-消费者问题是一个经典的线程同步问题,该问题最早由Dijkstra提出,用以演示他提出的信号量机制。
在同一个线程地址空间内执行的两个线程。
生产者线程生产物品,然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品,然后释放缓冲区。
当生产者线程生产物品时,如果没有空缓冲区可用,那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时,如果没有满的缓冲区,那么消费者线程将被阻塞,直到新的物品被生产出来。
多个生产/消费者在有界缓冲上操作。
它利用N个字节的共享内存作为有界循环缓冲区,利用写一字符模拟放一个产品,利用读一字符模拟消费一个产品。
当缓冲区空时消费者应阻塞睡眠,而当缓冲区满时生产者应当阻塞睡眠。
一旦缓冲区中有空单元,生产者线程就向空单元中入写字符,并报告写的内容和位置。
一旦缓冲区中有未读过的字符,消费者线程就从该单元中读出字符,并报告读取位置。
生产者不能向同一单元中连续写两次以上相同的字符,消费者也不能从同一单元中连续读两次以上相同的字符。
2完成步骤
2.1思路分析
本试验是练习生产者-消费者问题,成性能分析,使理解掌握线程的同步、通信以及互斥和多线程的安全问题。
一般情况下,解决互斥方法常用信号量和互斥锁,即semaphore和mutex,而解决这个问题,多采用一个类似资源槽的结构,每个槽位标示了指向资源的指针以及该槽位的状态,生产者和消费者互斥查询资源槽,判断是否有产品或者有空位可以生产,然后进行相应的操作。
同时,为了告诉生产者或者消费者资源槽的情况,还要有一个消息传送机制,无论是管道还是线程通信。
为了保证互斥要求,需要定义一个数据结构,这个数据结构包含两个指针,一个读一个写,同时有一个资源数目量,告诉生产者和消费者是否可以生产或者消费。
由于该数据结构很小,因而可以对此结构互斥访问。
同时,对于每组数据,都有一个标志位,表示此组数据是否被占用,生产者和消费者均可以先占用此位置然后完成相应的操作。
当消费者互斥访问此结构时,首先判断是否有数据可以取,如果没有,直接等待,若有数据可取,先更改标志位占用此数据,并将资源数目-1。
然后交出互斥,把数据拷贝到自己缓冲区内,清空数据。
当生产者访问时,首先判断有没有空位可以生产,如果没有,直接等待,若有数据可以生产,先判断该位是否被占用,如果没被占用,则占用此位置进行生产。
生产完成后,将占用位改为未占用,同时将资源数目+1。
2.2结构流程图
试验为生产者-消费者问题模型的实现,主程序中分别启动生产者线程和消费者线程。
生产者线程不断顺序地将0到9的数字写入共享的循环缓冲区,同时消费者线程不断地从共享的循环缓冲区读取数据。
试验流程图如下:
图2-1结构流程图
2.3重要函数
2.3.1源程序
试验代码:
/************main.c************/
#include "producer.h"
#include "customer.h"
#include "data.h"
#include
#include
/*******************************************************************
**实现生产者线程生产数据放入一个单向链表中,消费者线程负责消费数据**
********************************************************************/
int main(){
pthread_t thread_pro;
pthread_t thread_cons;
printf("create....\n");
//创建生产者线程。
pthread_create(&thread_pro,NULL,(void *)producer,NULL);
//创建消费者线程。
pthread_create(&thread_cons,NULL,(void *)customer,NULL);
printf("finished!
\n");
while
(1){
}
return 0;
}
/************data.h***********/
#ifndef DATA_H_
#define DATA_H_
//单向链表数据结构
struct product{
struct product *pre_product;
char product_data[20];
struct product *next_product;
};
//向单向链表中加入一个节点(生产)。
void addProduct(char *product_data);
//从单向链表中取出全部节点信息(消费)。
void consProduct();
#endif
/***********data.c************/
#include "data.h"
#include
#include
#include
struct product *present_product=NULL;
struct product *pre_product = NULL;
int lock=0;
void addProduct(char *product_data){
while(lock==1);
lock=1;
struct product *new_product=malloc(sizeof(struct product));
if(present_product==NULL){
new_product->pre_product=NULL;
strcpy( new_product->product_data,product_data);
new_product->next_product=NULL;
present_product=new_product;
}else{
new_product->pre_product=present_product;
strcpy( new_product->product_data,product_data);
new_product->next_product=NULL;
present_product->next_product=new_product;
present_product=new_product;
}
lock=0;
}
void consProduct(){
while(lock==1);
lock=1;
while(present_product!
=NULL){
pre_product=present_product->pre_product;
printf("%s\n",present_product->product_data);
if(pre_product!
=NULL){
pre_product->next_product=0;
}
free(present_product);
present_product=pre_product;
}
lock=0;
}
/*************producer.h*************/
#ifndef PRODUCER_H_
#define PRODUCER_H_
//生产者执行生产任务
void producer();
#endif
/*************producer.c**************/
#include "producer.h"
#include "data.h"
#include
#include
#include
int temp_i=0;
void producer(){
char temp[20]={0};
while
(1){
sprintf(temp,"number___%d",temp_i);
addProduct(temp);
temp_i++;
usleep((int)(rand()/2000));
}
}
/************customer.h***********/
#ifndef CUSTOMER_H_
#define CUSTOMER_H_
//消费者执行消费任务。
void customer();
#endif
/*************customer.c*************/
#include "customer.h"
#include "data.h"
#include
#include
void customer(){
while
(1){
consProduct();
printf("-------------\n");
usleep((int)(rand()/1000));
}
}
intmain(intargc,char**argv)
{
pthread_tproducer_id;
pthread_tconsumer_id;
pthread_create(&producer_id,NULL,producer,NULL);
void*producer(void*arg) {
pthread_detach(pthread_self());
while
(1)
{
pthread_mutex_lock(&mutex);
if(size==MALE_LENGTH){
printf("person:
buffisfull(producer)\n");
producer_wait=1;
pthread_cond_wait(&full_cond,&mutex);
producer_wait=0;
}
rear=(rear+1)%MALE_LENGTH;
buff[rear]=rand()%MALE_LENGTH;
printf("producer:
%d:
%d\n",rear,buff[rear]);
++size;
if(size==1){
while
(1){
if(consumer_wait){
pthread_cond_signal(&empty_cond);
break;
}
}
}
pthread_mutex_unlock(&mutex);
}
}
pthread_create(&consumer_id,NULL,consumer,NULL);
void*consumer(void*arg) {
pthread_detach(pthread_self());
while
(1){
pthread_mutex_lock(&mutex);
if(size==0){
printf("person:
buffisempty(consumer)\n");
consumer_wait=1;
pthread_cond_wait(&empty_cond,&mutex);
consumer_wait=0;
}
printf("consumer:
%d:
%d\n",front,buff[front]);
front=(front+1)%MALE_LENGTH;
--size;
if(size==MALE_LENGTH-1){
while
(1){
if(producer_wait){
pthread_cond_signal(&full_cond);
break;
}
}
}
pthread_mutex_unlock(&mutex);
}
}
sleep
(1);
return0;
}
2.3.2函数分析
生产者写入缓冲区和消费者从缓冲区读数的具体流程,生产者首先要获得互斥锁,并且判断资源槽是否已满,如果资源槽已满则进入等待状态,等待信号full;如果不满则向资源槽中写一个整数,并且释放信号为empty,最后释放互斥锁。
消费者线程与生产者线程类似,流程图如下:
图2-2生产消费流程图
1)生产者写入共享的循环缓冲区入口函数
首先我们需要线程分离,调用pthread_detach()即可,线程分离是不让其他线程等待,继续运行。
在主循环中我们需要给资源槽上锁,不让消费者函数访问,然后判断资源槽是否满,若为满就解锁资源槽,然后等待消费者激活信号full—_cond到来。
若没满就增加一个数值给资源槽,然后判断资源槽是否有数据,若有就激活消费者信号empty_cond来消费。
void*producer(void*arg) {
pthread_detach(pthread_self());
while
(1){
pthread_mutex_lock(&mutex);
if(size==MALE_LENGTH)
{
printf("person:
buffisfull(producer)\n");
producer_wait=1;
pthread_cond_wait(&full_cond,&mutex);
producer_wait=0;
}
rear=(rear+1)%MALE_LENGTH;
buff[rear]=rand()%MALE_LENGTH;
printf("producer:
%d:
%d\n",rear,buff[rear]);
++size;
if(size==1){
while
(1){
if(consumer_wait){
pthread_cond_signal(&empty_cond);
break;
}
}
}
pthread_mutex_unlock(&mutex);
}
}
2)消费者读取共享的循环缓冲区函数 GET
首先需要线程分离,调用pthread_detach()即可。
在主循环中我们需要给资源槽上锁,不让生产者函数访问,然后判断资源槽是否满,若不满就解锁资源槽,然后等待消生产者激活信号empty_cond到来。
若满就读取一个数值,然后判断资源槽是否有数据,若无就激活生产者信号full_cond来生产。
void*consumer(void*arg) {
pthread_detach(pthread_self());
while
(1){
pthread_mutex_lock(&mutex);
if(size==0){
printf("person:
buffisempty(consumer)\n");
consumer_wait=1;
pthread_cond_wait(&empty_cond,&mutex);
consumer_wait=0;
}
printf("consumer:
%d:
%d\n",front,buff[front]);
front=(front+1)%MALE_LENGTH;
--size;
if(size==MALE_LENGTH-1){
while
(1){
if(producer_wait){
pthread_cond_signal(&full_cond);
break;
}
}
}
pthread_mutex_unlock(&mutex);
}
}
3实验数据
3.1下载和调试截图
首先进入目录/mnt/hgfs/share/JXK,然后输入命令gccxiankun-j.c-oxiankun-j.exe-lpthread编译代码,之后运行可执行文件./xiankun-j.exe,运行结果如图3.1所示。
图3.1
4结果分析和总结
1、具体应用情况
生产者-消费者是一个很广泛的问题,代表了多线程互斥访问共享资源,以及线程之间通信的各种问题的总和。
这个可以从数据看出,简单有无等待的设置,可以让数据差异变的如此明显。
毕竟,在实际应用中,生产者如何生产数据,产生怎样的数据,而消费者又如何拿到数据,是通过管道还是内存共享区,拿到数据之后,是进行处理还是写入磁盘,都有可能,因而,简单通过几组数据来判断哪个进程的效率更高,是不科学的。
我们可以通过两个实际的例子来解释有无等待的情况。
有等待更像是在火锅店吃火锅,商家只要把锅准备好,将生菜切好端上来即可,而顾客大量的时间用在食用上,等待的时间也很少,这样资源位置会大量被消耗,但是实际资源消耗的速度很慢,但是由于空间被占用,生产者无法继续生产。
而无等待更像是快餐外卖,商家花大量时间将食物准备好,而消费者只需要交钱拿东西走人即可,资源位置空闲很多,消费者等待时间较长,但是处理数据的过程简单又节约资源。
这里还有一个问题,就是资源槽的数量,理论上这个方案应该放弃资源槽,但是从实际实现方法来看,只不过将每个资源槽的标志位移动到资源内部,然后通过读写指针进行查询,实际上这还是资源槽的变相实现方式。
但是单就资源槽的数目来看,是个很复杂的问题,要保证在生产者想生产的时候不会没槽位,而消费者查询资源槽状态又不会花费太长时间,这需要具体分析每个函数执行的时间,因而本实验中只是简单设计为消费者数量的1-3倍。
2、线程的调度情况
首先要考虑的是线程的调度顺序。
为了方便起见,每个线程在产生的时候都有一个编号,而创建也是按照1-Count这样的顺序for循环创建的。
如果线程调度的顺序和线程创建的顺序一样,那么在无等待情况下应该有这样的结果:
消费者远多于生产者,这样当生产者生产出数据时,前面几个优先完成等待并读取数据的进程就可以占据先机,拿到数据(这里不考虑数据消费的时间,因为程序的思路和食堂占座差不多,只要把位置占掉就可以了),而后面一些进程则由于位置不佳基本拿不到数据。
当然,插入等待时间也是一种解决资源分配的方式,这样可以保证每个线程都有机会获取到资源,不至于让某个线程连续的占用资源很长时间。
但是在实际情况下,每个线程完成工作不一样,又不可能像实验写出的进程那样无私,拿到资源后就自动等待,这就需要使用线程间通信机制了,让拿不到资源的线程挂起,生产者完成生产后再唤醒这些进程。
3、可能的改进
首先,就是线程调度的方式,忙等肯定不是一个好方法,如果换成线程间通信,轮流挂起或者唤醒某个线程,可能会更好。
其次,是消费者的资源分配问题。
程序设计的消费者有一个1024字节的buffer,用来处理接收到的数据,但是这个buffer直到线程消失才被回收,如果加上一些资源回收的机制可能会改善程序的性能。
最后,是对于生产者和消费者具体完成工作的问题,应该说这个实验设计的场景还是很简单,完全的内存拷贝,没有什么复杂运算和文件操作,而且由于手头没有原始版本的代码,无法比较两个代码的性能,整个程序的框架也是重新编写的,这应该也是一点不足。
通过这次试验的
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 基于 arm 多线程 应用 程序设计 大学 论文