05实验五 Linux环境下多线程应用程序实验
实验五 多线程编程

编译运行程序,观察程序的运行结果。若把源程序中加黑体的语句注释掉,程序的运行结果 和以前有什么不同,为什么? 程序 2:同步信号量的使用 1 //psy1.c #include <stdio.h> #include <stdlib.h> #include <semaphore.h> #include <pthread.h>
int rt; pthread_t pthread_t pt_dsp; pt_ctrl;
rt = sem_init (&smt, 0, 0); if (rt){ printf ("semaphore initialization failed"); } pthread_create (&pt_dsp, NULL, ThreadFuncDisplay, NULL); pthread_create (&pt_ctrl, NULL, ThreadFuncControl, NULL); sleep(20); return 0; }
printf("thread is working\n"); sleep(1); printf("thread is finished\n"); return NULL; } int main(void) { pthread_t mythread; if(pthread_create(&mythread,NULL,thread_function,NULL)) { printf("creating thread is failed\n"); abort(); } printf("main is joining thread\n"); sleep(6); if(pthread_join(mythread,NULL)) { printf("error joining thread\n"); abort(); //sleep(6); printf(“thread end!!”); } }
多线程程序实验报告(3篇)

第1篇一、实验目的1. 理解多线程的概念和作用。
2. 掌握多线程的创建、同步和通信方法。
3. 熟悉Java中多线程的实现方式。
4. 提高程序设计能力和实际应用能力。
二、实验环境1. 操作系统:Windows 102. 开发工具:IntelliJ IDEA3. 编程语言:Java三、实验内容本次实验主要完成以下任务:1. 创建多线程程序,实现两个线程分别执行不同的任务。
2. 使用同步方法实现线程间的同步。
3. 使用线程通信机制实现线程间的协作。
四、实验步骤1. 创建两个线程类,分别为Thread1和Thread2。
```javapublic class Thread1 extends Thread {@Overridepublic void run() {// 执行Thread1的任务for (int i = 0; i < 10; i++) {System.out.println("Thread1: " + i);}}}public class Thread2 extends Thread {@Overridepublic void run() {// 执行Thread2的任务for (int i = 0; i < 10; i++) {System.out.println("Thread2: " + i);}}}```2. 创建一个主类,在主类中创建两个线程对象,并启动它们。
```javapublic class Main {public static void main(String[] args) {Thread thread1 = new Thread1();Thread thread2 = new Thread2();thread1.start();thread2.start();}```3. 使用同步方法实现线程间的同步。
```javapublic class SynchronizedThread extends Thread {private static int count = 0;@Overridepublic void run() {for (int i = 0; i < 10; i++) {synchronized (SynchronizedThread.class) {count++;System.out.println(Thread.currentThread().getName() + ": " + count);}}}}public class Main {public static void main(String[] args) {Thread thread1 = new SynchronizedThread();Thread thread2 = new SynchronizedThread();thread1.start();thread2.start();}```4. 使用线程通信机制实现线程间的协作。
实验五 多线程程序设计 实验报告

实验五多线程程序设计实验报告一、实验目的1. 熟悉利用Thread 类建立多线程的方法。
2. 熟悉利用Runnable 接口建立多线程的方法。
二、实验原理1. 通过继承Thread 类实现多线程的方法:① 创建一个Thread 类的子类。
② 重写run 方法。
③ 创建这个子类的实例。
④调用子类的start 方法启动线程。
2. 通过Runnable 接口实现多线程的方法:① 创建一个线程类,实现Runnable 接口。
② 实现run 方法。
③ 通过Thread 类中的Thread(Runnable) 构造方法创建一个线程类实例。
④ 调用线程类的start 方法启动线程。
三、实验内容1. 阅读下列程序,分析并上机检验其功能。
class DelayThread extends Thread {private static int count=0;private int no;private int delay;public DelayThread() {count++;no=count;}public void run() {try {for (int i=0;i<10;i++){delay=(int)(Math.random()*5000);sleep(delay);System.out.println(“Thread ”+no+” with a delay ”+delay);} catch(InterruptedException e) { }}}public class MyThread {public static void main(String args[]) {DelayThread thread1 = new DelayThread();DelayThread thread2 = new DelayThread();thread1.start();thread2.start();try {Thread.sleep(1000);} catch (InterruptedException e) {System.out.println(“Thread wrong”);}}}2. 利用Runnable 接口修改上面的程序,使之完成同样的功能。
实验报告5Linux进程管理

实验报告5Linux进程管理实验五 Linux进程管理四、实验过程(实验步骤、记录、数据、分析、结果)(⼀)进程查看、终⽌、挂起及暂停等操作1、使⽤ps命令查看和控制进程1)显⽰本⽤户进程#ps2)显⽰所有⽤户的进程#ps–au3)在后台运⾏cat命令#cat&4)查看进程cat#ps aux |grep cat5)杀死进程cat#kill -9 cat6)再次查看进程cat,看看是否被杀死。
2、使⽤top命令查看和控制进程1)⽤top命令动态显⽰当前的进程。
2)只显⽰某⼀⽤户的进程(u)3)杀死指定进程号的进程(k)3、挂起和恢复进程1)执⾏命令cat2)按【ctrl+z】挂起进程3)输⼊jobs命令,查看作业4)输⼊bg,把cat切换到后台执⾏5)输⼊fg,把cat切换到前台执⾏6)按【ctrl+c】结束进程(⼆)通过at命令实现计划任务1、5分钟后执⾏/bin/date#at now+5minutesat>/bin/dateat>(提⽰:输⼊【ctrl+d】job任务号at 年-⽉-⽇⼩时:分钟如何查看结果?使⽤atq可以查询到已添加的at计划任务2、查找系统中任何以c为后缀名的⽂档,将结果保存到$HOME/findc⽂件中,指定时间为2016年12⽉01⽇早上8点#at 8am 12/01/16at>find / -name ‘*.c’>$HOME/findcat>job任务号at 年-⽉-⽇⼩时:分钟如何查看结果?使⽤atq可以查询到已添加的at计划任务3、2题的命令写到$HOME/findjob中,使⽤at命令执⾏,并将结果保存到$HOME/findfc⽂件中,指定时间为当前时间后5分钟#vi $HOME/findjob内容如下:find / -name ‘*.c’>$HOME/findfc存盘退出#at –f $HOME/findjob now+5minutes4、at命令实现在3天后统计/etc/inittab⽂件的⾏数,将统计结果发送⾄$HOME/initline⽂件中#at now+3daysat>wc–l /etc/inittab>>$HOME/initlineat>5.列出现有的所有at任务,并记下相关信息6、删除某at任务,并进⾏查看是否删除(三)通过cron命令实现计划任务1、使⽤cron命令实现12⽉每天下午2点系统进⾏维护状态,重新启动系统#vi $HOME/shutcron输⼊内容:00 14 * 12 * /sbin/shutdown–r存盘退出#crontab $HOME/shutcron2、使⽤cron命令实现在12⽉1号星期四的17点30分查看/etc/passwd内容,并将查看结果送⾄$HOME/passtext #vi $HOME/checkcron输⼊内容:30 17 1 12 4 more /etc/passwd>$HOME/passtext存盘退出#crontab $HOME/checkcron3、查看当前的crontab⽂件#crontab -l4、⽤户user的crontab⽂件#crontab –u user –r。
Linux并发编程实验(线程、进程)

Linux并发编程实验多线程、多进程编程一.实验目的和要求二、实验内容三、实验结果与分析1、进程实验(1)分别创立4个C文件,get.c、copy.c、put.c以及main.c分别实验读入,拷贝,输出,及前三个函数的调用;(2)定义三个缓冲区,其中一个记录对各项操作的选择,另外两个用来传输拷贝文件内容,相当于图中的缓冲区s和缓冲区t;(3)并发执行时定义了4个信号灯,分别用来控制缓冲区s是否有内容,缓冲区s是否空,缓冲区t是否有内容,缓冲区t是否为空;顺序执行时定义了三个信号灯,让get、copy、put分别其按顺序依次执行。
(4)创建三个进程分别实现get、copy、put功能;(5)并发时原理如下If(f不为空){get(s,f);while(誊抄未完成){t=s;cobeginput(t,g);get(s,f);coend;}}(6)顺序执行时原理如下:while(f不为空){input;output;}(7)创建一个字符文档如下,大小为42.4KB,内容为一连串的字符此时文件比较小用并发和顺序所得执行结果如下由此可知当文件很小时,并发执行和顺序执行比本感觉不出差距。
(8)创建一个一个较大的f.txt文档,大小为113.5KB,内容为一连串字符,如下:此时文件较大,并发执行和顺序执行的程序运行结果如下所示:此时才能看出两者之间有细小的差别,顺序执行效率小于并发执行的效率!但还是可见差距非常不明显!(9)分析:对于进程而言,顺序执行和并发执行之间的差距并不是那么明显,尤其是在拷贝文件较小时,基本感觉不出差距,只有在拷贝文件很大时才能有感觉到明显的差距。
2、线程实验(1)实验原理与进程一致,只是这次用的是一个thread。
C文件,内部有4个函数分别为get、copy、put、main来实现全部功能。
并且创建的为3个线程。
(2)创建一个f.txt文件,大小为113.5KB,内容为一串连续字符,如下所示并发和顺序的执行结果如下所示:并发执行的结果为4.83秒,而顺序执行在两分钟后还是没有完成,用ctrl+C打断,可见当要拷贝的文件很大时,线程的并发和顺序执行之间的差距是非常明显的!(3)创建一个较小的f.txt文件,大小为7.6KB,内容为一连串的字符,如下所示:此时的运行结果如下所示:可见,当拷贝的文件较小时,线程的顺序与并发执行指尖的差距也会变小。
Linux下多进程环境实验

/* journalling filesystem info */ void *journal_info;
unsigned long ptrace_message; siginfo_t *last_siginfo; /* For p *set_child_tid;
/* CLONE_CHILD_SETTID */
int *clear_child_tid;
/* CLONE_CHILD_CLEARTID */
unsigned long rt_priority; unsigned long it_real_value, it_prof_value, it_virt_value; unsigned long it_real_incr, it_prof_incr, it_virt_incr; struct timer_list real_timer; struct tms times; struct tms group_times; unsigned long start_time; long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS]; /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */ unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap; int swappable:1; /* process credentials */ uid_t uid,euid,suid,fsuid; gid_t gid,egid,sgid,fsgid; int ngroups; gid_t groups[NGROUPS]; kernel_cap_t cap_effective, cap_inheritable, cap_permitted; int keep_capabilities:1; struct user_struct *user; /* limits */ struct rlimit rlim[RLIM_NLIMITS]; unsigned short used_math; char comm[16]; /* file system info */ int link_count, total_link_count; struct tty_struct *tty; /* NULL if no tty */
2022年操作系统实验报告理解Linux下进程和线程的创建并发执行过程

操作系统上机实验报告实验名称:进程和线程实验目旳:理解unix/Linux下进程和线程旳创立、并发执行过程。
实验内容:1.进程旳创立2.多线程应用实验环节及分析:一、进程旳创立下面这个C程序展示了UNIX系统中父进程创立子进程及各自分开活动旳状况。
fork( )创立一种新进程。
系统调用格式:pid=fork( )参数定义:int fork( )fork( )返回值意义如下:0:在子进程中,pid变量保存旳fork( )返回值为0,表达目迈进程是子进程。
>0:在父进程中,pid变量保存旳fork( )返回值为子进程旳id值(进程唯一标记符)。
-1:创立失败。
如果fork( )调用成功,它向父进程返回子进程旳PID,并向子进程返回0,即fork( )被调用了一次,但返回了两次。
此时OS在内存中建立一种新进程,所建旳新进程是调用fork( )父进程(parent process)旳副本,称为子进程(child process)。
子进程继承了父进程旳许多特性,并具有与父进程完全相似旳顾客级上下文。
父进程与子进程并发执行。
2、参照程序代码/*process.c*/#include <stdio.h>#include <sys/types.h>main(int argc,char *argv[]){int pid;/* fork another process */pid = fork();if (pid < 0) { /* error occurred */fprintf(stderr, "Fork Failed");exit(-1);}else if (pid == 0) { /* child process */execlp( "/bin/ls", "ls",NULL);}else {/* parent process *//* parent will wait for the child to complete */ wait(NULL);printf( "Child Complete" );exit(0);}}3、编译和运营$gcc process.c –o processs4、运营$./process编辑如图所示:运营如图所示:思考:(1)系统是如何创立进程旳?1,申请空白PCB(进程控制块);2,为新进程分派资源;3,初始化PCB;4,将新进程插入就绪队列;(2)扩展程序,在父进程中输出1到5,在子进程中输出6-10,规定父子进程并发输出;记录实验成果,并给出简朴分析。
实验5Linux进程控制编程实验

实验5Linux进程控制编程实验实验5 Linux进程控制编程实验1、实验目的(1)熟悉多用户、多任务环境,通过实验,进一步牢固掌握进程的概念;(2)掌握Linux环境下进程的创建;(3)掌握Linux环境下进程的执行和传参要求;(4)熟悉进程间的通信。
2、实验要求1、实验必须在在Linux环境下进行操作。
2、文件名按照下面规则命名:源程序文件名最后要加学号后4位尾数。
如:f+学号最后4位.c3、实验报告中需要说明实验中在Linux环境下进行的实际操作;4、实验报告中应给出实际操作命令、所编写的程序、以及计算机输出的程序运行结果。
5、按照规定格式打印实验报告。
3、实验内容注意:(1)下面xxxx是自己学号的后4位尾数。
1、编写一个程序pxxxx.c,由它作为父进程去创建一个子进程。
并且父进程和子进程分别输出自己的进程号,同时输出你学号后4位尾数。
2、本题有两小题。
(1)运行下面程序,观察运行结果,并以下面的形式画出运行结果的进程树。
p1→p11→p111|→p12|→p13它表示进程p1创建了子进程p11、p12、p13;而p11又创建了子进程p11。
//pxxxx.c#include#includeint main(void){ int result,i;for(i=0;i<3;i++){result = fork();if(result == -1){perror("fork"); _exit(1);}if(result == 0){printf(" father's PID =%d --> child's PID =%d \n" ,getppid(),getpid() );}//waitpid(result,NULL,0);}printf("Now this is parent process, my PID = %d .\n",getpid());}(2)将循环控制变量i的值修改为2,并且去掉waitpid语句的注释,再编译并运行程序,观察运行结果并画出运行结果的进程树。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
在这一节里,我们编写了一个最简单的线程,并掌握了最常用的三个函数 pthread_create,pthread_join 和 pthread_exit。下面,我们来了解线程的一些常用属性以及 如何设置这些属性。
2、修改线程的属性
在上一节的例子里,我们用 pthread_create 函数创建了一个线程,在这个线程中,我 们使用了默认参数,即将该函数的第二个参数设为 NULL。的确,对大多数程序来说,使 用默认属性就够了,但我们还是有必要来了解一下线程的有关属性。
2) 使多 CPU 系统更加有效。操作系统会保证当线程数不大于 CPU 数目时,不同的 线程运行于不同的 CPU 上。
3) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程,成为几个独立或 半独立的运行部分,这样的程序会利于理解和修改。
六、实验说明
1、简单的多线程编程 Linux 系统下的多线程遵循 POSIX 线程接口,称为 pthread。编写 Linux 下的多线程 程序,需要使用头文件 pthread.h,连接时需要使用库 libpthread.a。顺便说一下,Linux 下 pthread 的实现是通过系统调用 clone()来实现的。clone()是 Linux 所特有的系统调用, 它的使用方式类似 fork,关于 clone()的详细情况,有兴趣的读者可以去查看有关文档 说明。下面我们展示一个最简单的多线程程序 example.c。 /* example.c*/ #include <stdio.h> #include <pthread.h> void thread(void) { int i; for(i=0;i<3;i++) printf("This is a pthread.\n"); } int main(void) { pthread_t id; int i,ret; ret=pthread_create(&id,NULL,(void *) thread,NULL); if(ret!=0){ printf ("Create pthread error!\n"); exit (1); } for(i=0;i<3;i++) printf("This is the main process.\n"); pthread_join(id,NULL); return (0); } 我们编译此程序:
pthread_attr_t attr;
pthread_t tid; /*初始化属性值,均设为默认值*/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, (void *) my_function, NULL); 线程的分离状态决定一个线程以什么样的方式来终止自己。在上面的例子中,我们采 用了线程的默认属性,即为非分离状态,这种情况下,原有的线程等待创建的线程结束。 只有当 pthread_join()函数返回时,创建的线程才算终止,才能释放自己占用的系统资 源。而分离线程不是这样子的,它没有被其他的线程所等待,自己运行结束了,线程也就 终止了,马上释放系统资源。程序员应该根据自己的需要,选择适当的分离状态。设置线 程分离状态的函数为 pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)。第二 个 参 数 可 选 为 PTHREAD_CREATE_DETACHED ( 分 离 线 程 ) 和 PTHREAD _CREATE_JOINABLE(非分离线程)。这里要注意的一点是,如果设置一个线程为分离线 程,而这个线程运行又非常快,它很可能在 pthread_create 函数返回之前就终止了,它终 止以后就可能将线程号和系统资源移交给其他的线程使用,这样调用 pthread_create 的线 程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施,最简单的方法之一 是可以在被创建的线程里调用 pthread_cond_timewait 函数,让这个线程等待一会儿,留出 足够的时间让函数 pthread_create 返回。设置一段等待时间,是在多线程编程里常用的方 法。但是注意不要使用诸如 wait()之类的函数,它们是使整个进程睡眠,并不能解决线 程同步的问题。 另外一个可能常用的属性是线程的优先级,它存放在结构 sched_param 中。用函数 pthread_attr_getschedparam 和函数 pthread_attr_setschedparam 进行存放,一般说来,我们 总是先取优先级,对取得的值修改后再存放回去。下面即是一段简单的例子。
属性结构为 pthread_attr_t,它同样在头文件/usr/include/pthread.h 中定义,喜欢追根问 底的人可以自己去查看。属性值不能直接设置,须使用相关函数进行操作,初始化的函数 为 pthread_attr_init,这个函数必须在 pthread_create 函数之前调用。属性对象主要包括是 否绑定、是否分离、堆栈地址、堆栈大小、优先级。默认的属性为非绑定、非分离、缺省 1M 的堆栈、与父进程同样级别的优先级。
设置线程绑定状态的函数为 pthread_attr_setscope,它有两个参数,第一个是指向属性 结构的指针,第二个是绑定类型,它有两个取值:PTHREAD_SCOPE_SYSTEM(绑定的) 和 PTHREAD_SCOPE_PROCESS(非绑定的)。下面的代码即创建了一个绑定的线程。
#include <pthread.h>
gcc example1.c -lpthread -o example1 运行 example1,我们得到如下结果:
This is the main process. This is a pthread. This is the main process. This is the main process. This is a pthread. This is a pthread. 再次运行,我们可能得到如下结果:
This is a pthread. This is the main process. This is a pthread. This is the main process. This is a pthread. This is the main process. 前后两次结果不一样,这是两个线程争夺 CPU 资源的结果。上面的示例中,我们使 用到了两个函数,pthread_create 和 pthread_join,并声明了一个 pthread_t 型的变量。 pthread_t 在头文件/usr/include/bits/pthreadtypes.h 中定义: typedef unsigned long int pthread_t; 它是一个线程的标识符。函数 pthread_create 用来创建一个线程,它的原型为: extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr, void *(*__start_routine) (void *), void *__arg)); 第一个参数为指向线程标识符的指针,第二个参数用来设置线程属性,第三个参数是 线程运行函数的起始地址,最后一个参数是运行函数的参数。这里,我们的函数 thread 不需要参数,所以最后一个参数设为空指针。第二个参数我们也设为空指针,这样将生成 默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时,函 数返回 0,若不为 0 则说明创建线程失败,常见的错误返回代码为 EAGAIN 和 EINVAL。 前者表示系统限制创建新的线程,例如线程数目过多了;后者表示第二个参数代表的线程 属性值非法。创建线程成功后,新创建的线程则运行参数三和参数四确定的函数,原来的 线程则继续运行下一行代码。 函数 pthread_join 用来等待一个线程的结束。函数原型为: extern int pthread_join __P ((pthread_t __th, void **__thread_return)); 第一个参数为被等待的线程标识符,第二个参数为一个用户定义的指针,它可以用来 存储被等待线程的返回值。这个函数是一个线程阻塞的函数,调用它的函数将一直等待到 被等待的线程结束为止,当函数返回时,被等待线程的资源被收回。一个线程的结束有两 种途径,一种是象我们上面的例子一样,函数结束了,调用它的线程也就结束了;另一种 方式是通过函数 pthread_exit 来实现。它的函数原型为: extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__)); 唯一的参数是函数的返回代码,只要 pthread_join 中的第二个参数 thread_return 不是 NULL,这个值将被传递给 thread_return。最后要说明的是,一个线程不能被多个线程等 待,否则第一个接收到信号的线程成功返回,其余调用 pthread_join 的线程则返回错误代 码 ESRCH。