程序实验211多线程编程实验报告Word文件下载.docx
《程序实验211多线程编程实验报告Word文件下载.docx》由会员分享，可在线阅读，更多相关《程序实验211多线程编程实验报告Word文件下载.docx（21页珍藏版）》请在冰豆网上搜索。
for（count=0;
count<
P_NUMBER;
count++）
{
delay_time=（int）（rand（）*TIME/（RAND_MAX））+1;
sleep（delay_time）;
\tTH%d:
job%ddelay=%d\n"
thrd_num,count,delay_time）;
}
%dfinished\n"
pthread_exit（NULL）;
intmain（）
pthread_tthread[T_NUMBER];
intno=0,res;
void*thrd_ret;
srand（time（NULL））;
for（no=0;
no<
T_NUMBER;
no++）
res=pthread_create（&
thread[no],NULL,thrd_func,（void*）no）;
if（res!
=0）
Creayth%dfaild\n"
no）;
exit（res）;
success\nwaiting\n"
）;
res=pthread_join（thread[no],&
thrd_ret）;
if（!
res）
t%djoined\n"
else
T%djoinedfaild\n"
return0;
}
4．编译、运行方法及结果（抓屏）
5．结果分析
由运行结果可以看出，创建线程、释放资源按照顺序，而每个线程的运行和结束是独立与并行的。
实验二（p287:
11-thread_mutex.c）
在试验1的基础上通过互斥锁，使原本独立，无序的多个线程能够按顺序进行
#defineTHREAD_NUMBER3/*线程数*/
#defineREPEAT_NUMBER3/*每个线程的小任务数*/
#defineDELAY_TIME_LEVELS10.0/*小任务间的最大时间间隔*/
pthread_mutex_tmutex;
void*thrd_func（void*arg）//线程函数例程
intthrd_num=（int）arg;
intdelay_time=0,count=0;
intres;
//互斥锁上锁
res=pthread_mutex_lock（&
mutex）;
if（res）
Thread%disstarting\n"
thrd_num）;
for（count=0;
count<
REPEAT_NUMBER;
count++）
delay_time=（int）（rand（）*DELAY_TIME_LEVELS/（RAND_MAX））+1;
\tThread%d:
job%ddelay=%d\n"
thrd_num,count,delay_time）;
Thread%dfinished\n"
intmain（void）
pthread_tthread[THREAD_NUMBER];
intno=0,res;
pthread_mutex_init（&
mutex,NULL）;
for（no=0;
no<
THREAD_NUMBER;
no++）
res=pthread_create（&
thread[no],NULL,thrd_func,（void*）no）;
if（res!
=0）
Createthread%dfailed\n"
no）;
Createthreadssuccess\nWaitingforthreadstofinish...\n"
/*这里的问题很奇怪，按照书上程序敲打，出现的线程首先是2而非0，没有按照书上所说：
与创建顺序相同，但是在这里体现了互斥性，由于后面的释放资源程序从0开始，而一开始为线程2占用资源，所以无法释放资源，导致程序卡死，最后修改为先释放线程2的资源，之后则可以依次显示*/
for（no=2;
no--）
res=pthread_join（thread[no],&
Thread%djoined\n"
no）;
Thread%djoinfailed\n"
pthread_mutex_unlock（&
pthread_mutex_destroy（&
实验结果体现了互斥性，3个线程有序运行。
实验三（P291：
11-thread_sem.c）
该程序在实验1的基础上，用信号量同步机制实现3个线程的有序执行，利用pv操作来控制执行顺序，达到执行的顺序和创建的顺序刚好相反。
……
semaphore.h>
#defineTHREAD_NUMBER3
#defineREPEAT_NUMBER3
#defineDELAY_TIME_LEVELS10.0
sem_tsem[THREAD_NUMBER];
void*thrd_func（void*arg）
intthrd_num=（int）arg;
intdelay_time=0;
intcount=0;
sem_wait（&
sem[thrd_num]）;
printf（"
for（count=0;
delay_time=（int）（rand（）*DELAY_TIME_LEVELS/（RAND_MAX））+1;
sleep（delay_time）;
pthread_exit（NULL）;
pthread_tthread[THREAD_NUMBER];
intno=0,res;
void*thrd_ret;
srand（time（NULL））;
for（no=0;
no++）
sem_init（&
sem[no],0,0）;
res=pthread_create（&
if（res!
=0）
exit（res）;
sem_post（&
sem[THREAD_NUMBER-1]）;
for（no=THREAD_NUMBER-1;
no>
=0;
res=pthread_join（thread[no],&
if（!
else
sem[（no+THREAD_NUMBER-1）%THREAD_NUMBER]）;
no++）
sem_destroy（&
sem[no]）;
return0;
程序运行、结束都是按照顺序进行的，只是顺序和创建的顺序刚好相反。
实验四（p295:
11-thread_attr.c）
创建一个线程，具有绑定和分离属性，主线程通过finish——flag标志变量来获得线程结束的消息，不调用pthread_join函数
#defineDELAY_TIME_LEVELS10.0
intfinish_flag=0;
Thisstarting\n"
for（count=0;
delay_time=（int）（rand（）*DELAY_TIME_LEVELS/（RAND_MAX）+1）;
\tTh:
count,delay_time）;
Thfinished\n"
finish_flag=1;
pthread_tthread;
pthread_attr_tattr;
res=pthread_attr_init（&
attr）;
Createattributefailed\n"
res=pthread_attr_setscope（&
attr,PTHREAD_SCOPE_SYSTEM）;
res+=pthread_attr_setdetachstate（&
attr,PTHREAD_CREATE_DETACHED）;
if（res!
Settingattributefailed\n"
th,&
attr,thrd_func,NULL）;
Createthfailed\n"
}
pthread_attr_destroy（&
Createthsuccess\n"
while（!
finish_flag）
Waitingforthtofinish...\n"
sleep
（2）;
由结果可以看出，这个创建的线程具有绑定好而分离属性，而且主线程通过一个finish_glag标志变量赖获得线程结束的消息，但是线程在运行结束之后似乎没有收回系统资源，因为程序运行前和程序运行后使用“free”命令查看内存使用情况，发现使用的内存并不一致。
实验五（p298:
11-producer-customer.c）
信号量的意义，在程序生产中和消费过程中是随机进行的，而且生产者的速度比消费者的速度平均快两倍。
生产者一次生产一个单元产品，消费者一次消费一个单元的产品。
unistd.h>
fcntl.h>
errno.h>
sys/ipc.h>
#defineMYFIFO"
myfifo"
#defineBUFFER_SIZE3
#defineUNIT_SIZE5
#defineRUN_TIME30
#defineDELAY_TIME_LEVELS5.0
intfd;
time_tend_time;
sem_tmutex,full,avail;
void*producer（void*arg）
intreal_write;
intdelay_time=0;
while（time（NULL）<
end_time）
delay_time=（int）（rand（）*DELAY_TIME_LEVELS/（RAND_MAX）/2.0）+1;
avail）;
\nProducer:
delay=%d\n"
delay_time）;
if（（real_write=write（fd,"
hello"
UNIT_SIZE））==-1）
if（errno==EAGAIN）
TheFIFOhasnotbeenreadyet.Pleasetrylatter\n"
Write%dtotheFIFO\n"
real_write）;
full）;
void*customer（void*arg）
unsignedcharread_buffer[UNIT_SIZE];
intreal_read;
intdelay_time;
delay_time=（int）（rand（）*DELAY_TIME_LEVELS/（RAND_MAX））+1;
memset（read_buffer,0,UNIT_SIZE）;
\nCustomer:
delay_time）;
if（（real_read=read（fd,read_buffer,UNIT_SIZE））==-1）
Nodatayet\n"
Read%sfromFIFO\n"
read_buffer）;
pthread_tthrd_prd_id,thrd_cst_id;
pthread_tmon_th_id;
intret;
end_time=time（NULL）+RUN_TIME;
if（（mkfifo（MYFIFO,O_CREAT|O_EXCL）<
0）&
&
（errno!
=EEXIST））
Cannotcreatefifo\n"
returnerrno;
fd=open（MYFIFO,O_RDWR）;
if（fd==-1）
Openfifoerror\n"
returnfd;
ret=sem_init（&
mutex,0,1）;
ret+=sem_init（&
avail,0,BUFFER_SIZE）;
full,0,0）;
if（ret!
Anysemaphoreinitializationfailed\n"
returnret;
ret=pthread_create（&
thrd_prd_id,NULL,producer,NULL）;
if（ret!
Createproducerthreaderror\n"
thrd_cst_id,NULL,customer,NULL）;
Createcustomerthreaderror\n"
pthread_join（thrd_prd_id,NULL）;
pthread_join（thrd_cst_id,NULL）;
close（fd）;
unlink（MYFIFO）;
由实验结果可以看出生产者的速度比消费者的速度平均快2倍左右。
升级会员 