下载文档原格式
第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进程管理实验五 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并发编程实验多线程、多进程编程一．实验目的和要求二、实验内容三、实验结果与分析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，内容为一连串的字符，如下所示:此时的运行结果如下所示：可见，当拷贝的文件较小时，线程的顺序与并发执行指尖的差距也会变小。
操作系统上机实验报告实验名称：进程和线程实验目旳：理解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进程控制编程实验实验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. 通过实验加深对多线程编程的理解，提高编程能力。
二、实验环境硬件：PC机软件：VMware虚拟机、Linux系统、C/C++编译器三、实验内容1. 多线程创建与运行2. 线程同步与互斥3. 线程通信与协作4. 线程调度与优先级5. 生产者-消费者问题四、实验步骤1. 多线程创建与运行（1）创建线程：使用pthread_create函数创建线程，指定线程的入口函数、参数、线程属性等。
（2）线程运行：编写线程入口函数，实现线程需要执行的任务。
（3）线程结束：在线程入口函数中执行任务后，使用pthread_exit函数结束线程。
2. 线程同步与互斥（1）互斥锁：使用pthread_mutex_lock和pthread_mutex_unlock函数实现互斥锁，保证同一时刻只有一个线程访问共享资源。
（2）条件变量：使用pthread_cond_wait和pthread_cond_signal函数实现条件变量，实现线程间的同步与协作。
（3）读写锁：使用pthread_rwlock_rdlock和pthread_rwlock_wrlock函数实现读写锁，允许多个线程同时读取共享资源，但只有一个线程可以写入。
3. 线程通信与协作（1）线程间通信：使用pthread_cond_signal、pthread_cond_broadcast、pthread_barrier_wait等函数实现线程间的通信。
（2）线程协作：使用pthread_barrier_init、pthread_barrier_wait函数实现线程间的协作，确保所有线程到达某个点后再继续执行。
4. 线程调度与优先级（1）线程调度：了解操作系统的线程调度算法，如时间片轮转、优先级调度等。
（2）线程优先级：使用pthread_setschedparam函数设置线程的调度策略和优先级。
linux shell多线程编程实例Linux Shell是一种命令行解释器，可以通过编写Shell脚本来实现自动化任务。
在Shell脚本中，我们可以使用多线程编程来同时执行多个任务，提高程序的执行效率。
本文将介绍如何在Linux Shell中实现多线程编程，并给出一个实际的例子。
在Linux Shell中，我们可以使用`&`符号来将任务放到后台执行，实现并发执行的效果。
但是这种方式并不是真正的多线程，因为它们共享同一个进程空间，无法充分利用多核处理器的优势。
为了实现真正的多线程并发执行，我们可以使用`parallel`命令。
`parallel`命令是一个用于并行执行任务的工具，它可以将任务分成多个子任务，并在多个CPU核心上并行执行。
使用`parallel`命令，我们可以很方便地实现多线程编程。
下面是一个使用`parallel`命令实现多线程编程的例子。
假设我们有一个包含1000个文件的目录，我们需要对每个文件进行处理。
我们可以使用以下命令来并行处理这些文件：```shellls /path/to/files | parallel -j 4 --progress process_file {} ```上面的命令中，`ls /path/to/files`会列出目录中的所有文件，`parallel -j 4`表示最多同时执行4个任务，`--progress`会显示任务的进度，`process_file`是一个自定义的处理函数，`{}`表示当前文件名。
在上面的例子中，`parallel`命令会将`ls /path/to/files`的输出作为参数传递给`process_file`函数，并在后台启动多个进程来并行执行这些任务。
每个进程会处理一个文件，直到所有文件都被处理完毕。
在`process_file`函数中，我们可以编写具体的文件处理逻辑。
例如，可以使用`grep`命令来搜索文件中的关键字，或者使用`sed`命令来替换文件中的内容。
linux多线程编程实验心得在进行Linux多线程编程实验后，我得出了一些心得体会。
首先，多线程编程是一种高效利用计算机资源的方式，能够提高程序的并发性和响应性。
然而，它也带来了一些挑战和注意事项。
首先，线程同步是多线程编程中需要特别关注的问题。
由于多个线程同时访问共享资源，可能会引发竞态条件和数据不一致的问题。
为了避免这些问题，我学会了使用互斥锁、条件变量和信号量等同步机制来保护共享数据的访问。
其次，线程间通信也是一个重要的方面。
在实验中，我学会了使用线程间的消息队列、管道和共享内存等方式来实现线程间的数据传递和协作。
这些机制可以帮助不同线程之间进行有效的信息交换和协调工作。
此外，线程的创建和销毁也需要注意。
在实验中，我学会了使用pthread库提供的函数来创建和管理线程。
同时，我也了解到线程的创建和销毁是需要谨慎处理的，过多或过少的线程都可能导致系统资源的浪费或者性能下降。
在编写多线程程序时，我还学会了合理地划分任务和资源，以充分发挥多线程的优势。
通过将大任务拆分成多个小任务，并将其分配给不同的线程来并行执行，可以提高程序的效率和响应速度。
此外，我还学会了使用调试工具来分析和解决多线程程序中的问题。
通过使用gdb等调试器，我可以观察线程的执行情况，查找潜在的错误和死锁情况，并进行相应的修复和优化。
总结起来，通过实验我深刻认识到了多线程编程的重要性和挑战性。
合理地设计和管理线程，正确处理线程同步和通信，以及使用调试工具进行分析和修复问题，都是编写高效稳定的多线程程序的关键。
通过不断实践和学习，我相信我能够更好地应用多线程编程技术，提升程序的性能和可靠性。
多线程实验报告多线程实验报告引言：多线程是计算机科学中的一个重要概念，它允许程序同时执行多个任务，提高了计算机的效率和响应能力。
本实验旨在探索多线程的原理和应用，通过编写并运行多线程程序，研究多线程在不同场景下的表现和效果。
一、实验目的本实验的目的是通过编写多线程程序，深入了解多线程的工作原理和应用场景，掌握多线程编程的技巧和方法。
二、实验环境本实验使用Java语言进行多线程编程，运行环境为Windows操作系统。
三、实验过程1. 线程的创建与启动在Java中，创建一个线程可以通过继承Thread类或实现Runnable接口来实现。
本实验选择实现Runnable接口的方式来创建线程。
```javapublic class MyThread implements Runnable {public void run() {// 线程的执行逻辑}}public class Main {public static void main(String[] args) {Thread thread = new Thread(new MyThread());thread.start();}}```通过上述代码，我们创建了一个名为MyThread的线程类，并在Main类的main方法中创建并启动了一个线程。
2. 线程的同步与互斥在多线程编程中，线程的同步与互斥非常重要。
为了保证线程的安全性，我们需要使用锁机制来控制多个线程对共享资源的访问。
```javapublic class MyThread implements Runnable {private static int count = 0;private static Object lock = new Object();public void run() {synchronized (lock) {for (int i = 0; i < 100; i++) {count++;}}}}public class Main {public static void main(String[] args) {Thread thread1 = new Thread(new MyThread());Thread thread2 = new Thread(new MyThread());thread1.start();thread2.start();}}```上述代码中，我们使用了一个静态对象lock作为锁，通过synchronized关键字来实现对共享资源count的互斥访问。
1 / 18实验八 Linux 多线程实验报告撰写人专业班级 学号姓名 完成时间。
。
。
。
一、 实验目的1、 了解什么是多线程，熟悉LINUX 的多线程机制；2、 掌握利用信号处理Linux 多线程的同步问题；3、掌握利用信号量处理Linux 多线程的互斥问题；4、 运用Linux 多线程的同步机制和互斥机制实现生产者消费者的编程。
二、 实验内容1． “生产者-消费者”问题如下：有一个有限缓冲区和两个线程：生产者和消费者。
他们分别不停地把产品放入缓冲区、从缓冲区中拿走产品。
一个生产者在缓冲区满的时候必须等待，一个消费者在缓冲区空的时候也必须等待。
另外，因为缓冲区是临界资源，所以生产者和消费者之间必须互斥执行。
它们之间的关系如图1所示。
现在要求使用共享内存来模拟有限缓冲区，并且使用信号量来解决“生产者-消费者”问题中的同步和互斥问题。
生产者和消费者问题描述2. 问题描述：假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。
吃东西的时候，他们就停止思考，思考的时候也停止吃东西。
餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉。
因为用一只餐叉很难吃到意大利面，所以假设哲学家必须用两只餐叉吃东西。
他们只能使用自己左右手边的那两只餐叉。
请用Linux 线程编程解决。
2 哲学家进餐问题示意图三、实验过程与结果操作过程错误解决方法实验1 步骤一：编写producer_customer.c的文件在不同的编译器中for循环的用法不太一样，在这里最好不要使用for（inti=0；；）最好在外声明inti在for循环里直接写i=02/ 18步骤二：编译代码并且运行代码步骤三：运行完毕后，显示以下代码：生产者消费者先后生产数据以及取出数据，此程序中设置了两个消费者两个生产者，交替进行生产数据消费数据。
实验步骤一：编写philosopher.c的文件3/ 182步骤二：编译代码并且运行代码步骤三：4/ 18实验代码实验一：#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <time.h>#include <sys/ipc.h>#include <sys/shm.h>#include <sys/sem.h>#include <sys/types.h>#define MAX_BUFFER_SIZE 105/ 18#define SHM_MODE 0600#define SEM_MODE 0600#define SEM_FULL 0#define SEM_EMPTY 1#define MUTEX 2/*#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)// union semun is defined by including <sys/sem.h>#else// according to X/OPEN we have to define it ourselvesunion semun{int val;struct semid_ds *buf;unsigned short *array;};#endifunion semun su;//sem union，用于初始化信号量*/struct my_buffer{int head;int tail;char str[MAX_BUFFER_SIZE];int num; //缓冲区里字母数量int is_empty;};const int N_CONSUMER = 2;//消费者数量const int N_PRODUCER = 2;//生产者数量const int N_BUFFER = 10;//缓冲区容量6/ 18const int N_WORKTIME = 10;//工作次数int shm_id = -1;int sem_id = -1;pid_t child;pid_t parent;//得到10以内的一个随机数int get_random(){int digit;srand((unsigned)(getpid() + time(NULL)));digit = rand() % 10;return digit;}//得到A～Z的一个随机字母char getRandChar(){char letter;srand((unsigned)(getpid() + time(NULL)));letter = (char)((rand() % 26) + 'A');return letter;}//sem_id 表示信号量集合的 id//sem_num 表示要处理的信号量在信号量集合中的索引//P操作void waitSem(int sem_id,int sem_num){struct sembuf sb;sb.sem_num = sem_num;sb.sem_op = -1;//表示要把信号量减一7/ 18sb.sem_flg = SEM_UNDO;////第二个参数是 sembuf [] 类型的，表示数组//第三个参数表示第二个参数代表的数组的大小if(semop(sem_id,&sb,1) < 0){perror("waitSem failed");exit(1);}}//V操作void sigSem(int sem_id,int sem_num){struct sembuf sb;sb.sem_num = sem_num;sb.sem_op = 1;sb.sem_flg = SEM_UNDO;//第二个参数是 sembuf [] 类型的，表示数组//第三个参数表示第二个参数代表的数组的大小if(semop(sem_id,&sb,1) < 0){perror("sigSem failed");exit(1);}}//打印进程运行结果void printTime(){//打印时间time_t now;struct tm *timenow; //实例化tm结构指针time(&now);8/ 18timenow = localtime(&now);printf("执行时间： %s ",asctime(timenow));}int main(int argc, char ** argv){shm_id = shmget(IPC_PRIVATE,MAX_BUFFER_SIZE,SHM_MODE); //申请共享内存if(shm_id < 0){perror("create shared memory failed");exit(1);}struct my_buffer *shmptr;shmptr = shmat(shm_id, 0, 0); //将申请的共享内存附加到申请通信的进程空间if (shmptr == (void*)-1){perror("add buffer to using process space failed！\n");exit(1);}if((sem_id = semget(IPC_PRIVATE,3,SEM_MODE)) < 0){ //创建三个信号量，SEM_EMPTY,SEM_FULL和MUTEXperror("create semaphore failed! \n");exit(1);}if(semctl(sem_id,SEM_FULL,SETVAL,0) == -1){ //将索引为0的信号量设置为0-->SEM_FULLperror("sem set value error! \n");9/ 18exit(1);}if(semctl(sem_id,SEM_EMPTY,SETVAL,10) == -1){ //将索引为1的信号量设置为10-->SEM_EMPTYperror("sem set value error! \n");exit(1);}if(semctl(sem_id,MUTEX,SETVAL,1) == -1){ //将索引为3的信号量设置为1-->MUTEXperror("sem set value error! \n");exit(1);}shmptr -> head = 0;shmptr -> tail = 0;shmptr -> is_empty = 1;shmptr -> num = 0;int i;for(i = 0; i < N_PRODUCER; i++){parent = fork();if(parent < 0){perror("the fork failed");exit(1);}else if(parent == 0){shmptr = shmat(shm_id, 0, 0); //将申请的共享内存附加到申请通信的进程空间10/ 18if (shmptr == (void*)-1){perror("add buffer to using process space failed！\n");exit(1);}int count = 0;int j;for(j = 0; j < N_WORKTIME; j++){waitSem(sem_id, SEM_EMPTY);waitSem(sem_id, MUTEX);sleep(get_random());printf("-------------------------------------------------------------\n");printf("我是第 %d 个生产者进程，PID = %d\n", i + 1, getpid());/*生产产品*/char c = getRandChar(); //随机获取字母shmptr -> str[shmptr->tail] = c;shmptr -> tail = (shmptr->tail + 1) % MAX_BUFFER_SIZE;shmptr -> is_empty = 0; //写入新产品shmptr -> num++;/*打印输出结果*/printTime(); //程序运行时间int p;printf("缓冲区数据（%d个）：",shmptr -> num); //打印缓冲区中的数据p = (shmptr->tail-1 >= shmptr->head) ? (shmptr->tail-1) :(shmptr->tail-1 + MAX_BUFFER_SIZE);11/ 18for (p; !(shmptr -> is_empty) && p >= shmptr -> head; p--){printf("%c", shmptr -> str[p % MAX_BUFFER_SIZE]);}printf("\t 生产者 %d 放入 '%c'. \n", i + 1, c);printf("-------------------------------------------------------------\n");fflush(stdout);sigSem(sem_id, MUTEX);sigSem(sem_id, SEM_FULL);}//将共享段与进程之间解除连接shmdt(shmptr);exit(0);}}for(i = 0; i < N_CONSUMER; i++){child = fork();if(child < 0)//调用fork失败{perror("the fork failed");exit(1);}else if(child == 0){int count = 0;shmptr = shmat(shm_id, 0, 0); //将申请的共享内存附加到申请通信的12/ 18进程空间if (shmptr == (void*)-1){perror("add buffer to using process space failed！\n");exit(1);}int j;for(j = 0; j < N_WORKTIME; j++){waitSem(sem_id, SEM_FULL);waitSem(sem_id, MUTEX);sleep(get_random());printf("-------------------------------------------------------------\n");printf("我是第 %d 个消费者进程，PID = %d\n", i + 1, getpid());/*消费数据*/char lt = shmptr -> str[shmptr -> head];shmptr -> head = (shmptr -> head + 1) % MAX_BUFFER_SIZE;shmptr -> is_empty = (shmptr->head == shmptr->tail); //shmptr -> num--;/*打印输出结果*/printTime(); //程序运行时间int p;printf("缓冲区数据（%d个）：",shmptr -> num); //打印缓冲区中的数据p = (shmptr -> tail - 1 >= shmptr -> head) ? (shmptr -> tail-1) :(shmptr -> tail - 1 + MAX_BUFFER_SIZE);for (p; !(shmptr -> is_empty) && p >= shmptr -> head; p--)13/ 18{printf("%c", shmptr -> str[p % MAX_BUFFER_SIZE]);}printf("\t 消费者 %d 取出 '%c'. \n", i + 1, lt);printf("-------------------------------------------------------------\n");fflush(stdout);sigSem(sem_id,MUTEX);sigSem(sem_id,SEM_EMPTY);}//将共享段与进程之间解除连接shmdt(shmptr);exit(0);}}//主进程最后退出while (wait(0) != -1);//将共享段与进程之间解除连接shmdt(shmptr);//对共享内存区执行控制操作shmctl(shm_id,IPC_RMID,0);//当cmd为IPC_RMID时，删除该共享段shmctl(sem_id,IPC_RMID,0);printf("主进程运行结束！\n");fflush(stdout);exit(0);return 0;}14/ 18实验二：#include<sys/types.h>#include<unistd.h>#include<stdlib.h>#include<stdio.h>#include<pthread.h>#include<semaphore.h>#include<time.h>#define N 5 //哲学家数量#define LEFT(i) (i+N-1)%N //左手边哲学家编号#define RIGHT(i) (i+1)%N //右手边哲家编号#define HUNGRY 0 //饥饿#define THINKING 1 //思考#define EATING 2 //吃饭#define U_SECOND 1000000 //1秒对应的微秒数pthread_mutex_t mutex; //互斥量int state[N]; //记录每个哲学家状态//每个哲学家的思考时间，吃饭时间，思考开始时间，吃饭开始时间clock_t thinking_time[N], eating_time[N], start_eating_time[N],start_thinking_time[N];//线程函数void *thread_function(void *arg);int main(){15/ 18pthread_mutex_init(&mutex, NULL);pthread_t a,b,c,d,e;//为每一个哲学家开启一个线程，传递哲学家编号pthread_create(&a,NULL,thread_function,"0");pthread_create(&b,NULL,thread_function,"1");pthread_create(&c,NULL,thread_function,"2");pthread_create(&d,NULL,thread_function,"3");pthread_create(&e,NULL,thread_function,"4");//初始化随机数种子srand((unsigned int)(time(NULL)));while(1){;}}void *thread_function(void *arg){char *a = (char *)arg;int num = a[0] - '0'; //根据传递参数获取哲学家编号int rand_time;while(1){//关键代码加锁pthread_mutex_lock(&mutex);//如果该哲学家处于饥饿并且左右两位哲学家都没有在吃饭就拿起叉子吃饭if(state[num] == HUNGRY && state[LEFT(num)] != EATING &&16/ 18state[RIGHT(num)] != EATING){state[num] = EATING;start_eating_time[num] = clock(); //记录开始吃饭时间eating_time[num] = (rand() % 5 + 5) * U_SECOND; //随机生成吃饭时间//输出状态printf("state: %d %d %d %d %d\n",state[0],state[1],state[2],state[3],state[4]);//printf("%d is eating\n",num);}else if(state[num] == EATING){//吃饭时间已到，开始思考if(clock() - start_eating_time[num] >= eating_time[num]) //{state[num] = THINKING;//printf("%d is thinking\n",num);printf("state: %d %d %d %d %d\n",state[0],state[1],state[2],state[3],state[4]);start_thinking_time[num] = clock(); //记录开始思考时间thinking_time[num] = (rand() % 10 + 10) * U_SECOND; //随机生成思考时间}}else if(state[num] == THINKING){17/ 18//思考一定时间后，哲学家饿了，需要吃饭if(clock() - start_thinking_time[num] >= thinking_time[num]){state[num] = HUNGRY;printf("state: %d %d %d %d %d\n",state[0],state[1],state[2],state[3],state[4]);// printf("%d is hungry\n",num);}}pthread_mutex_unlock(&mutex);}}四、实验小结生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。
《操作系统》实验报告用gcc编译的时候需要加-lpthread,否则会出现以下错误：五、思考题多进程编程与多线程编程有何区别？相同点：Linux下不管是多线程编程还是多进程编程，最终都是用do_fork 实现不同点：父子进程变量是互不影响的，由于父子进程地址空间是完全隔开的，变量的地址可以是完全相同的。
Linux下编程多用多进程编程少用多线程编程。
多线程比多进程成本低，但性能更低：多进程是立体交通系统，虽然造价高，上坡下坡多耗点油，但是不；多线程是平面交通系统，造价低，但红绿灯太多，老堵车。
1、多进程：子进程是父进程的复制品。
子进程获得父进程数据空间、堆和栈的复制品。
2、多线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
两者都可以提高程序的并发度，提高程序运行效率和响应时间。
3、线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。
同时，线程适合于在5MP机器上运行，而进程则可以跨机器迁移。
代码：#include <pthread.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>char globe_buffer[100];void *read_buffer_thread(void *arg);int main(){int res,i;pthread_t read_thread;for(i=0;i<20;i++)globe_buffer[i]=i;printf("\nxiancheng thread : write buffer finish\n");sleep(3);res = pthread_create(&read_thread, NULL, read_buffer_thread, NULL);if (res != 0){printf("Read Thread creat Error!");exit(0);}sleep(1);printf("waiting for read thread to finish...\n");res = pthread_join(read_thread, NULL);if (res != 0){printf("read thread join failed!\n");exit(0);}printf("read thread xiancheng OK, have fun!! exit ByeBye\n");return 0;}void *read_buffer_thread(void *arg){int i,x;printf("Read buffer thread read data : \n");for(i=0;i<20;i++){x=globe_buffer[i];printf("%d ",x);globe_buffer[i]=0;}printf("\nread over\n");}。
Linux下的多线程编程实例解析1 引⾔ 线程（thread）技术早在60年代就被提出，但真正应⽤多线程到操作系统中去，是在80年代中期，solaris是这⽅⾯的佼佼者。
传统的Unix也⽀持线程的概念，但是在⼀个进程（process）中只允许有⼀个线程，这样多线程就意味着多进程。
现在，多线程技术已经被许多操作系统所⽀持，包括Windows/NT，当然，也包括Linux。
为什么有了进程的概念后，还要再引⼊线程呢？使⽤多线程到底有哪些好处？什么的系统应该选⽤多线程？我们⾸先必须回答这些问题。
使⽤多线程的理由之⼀是和进程相⽐，它是⼀种⾮常"节俭"的多任务操作⽅式。
我们知道，在Linux系统下，启动⼀个新的进程必须分配给它独⽴的地址空间，建⽴众多的数据表来维护它的代码段、堆栈段和数据段，这是⼀种"昂贵"的多任务⼯作⽅式。
⽽运⾏于⼀个进程中的多个线程，它们彼此之间使⽤相同的地址空间，共享⼤部分数据，启动⼀个线程所花费的空间远远⼩于启动⼀个进程所花费的空间，⽽且，线程间彼此切换所需的时间也远远⼩于进程间切换所需要的时间。
据统计，总的说来，⼀个进程的开销⼤约是⼀个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较⼤的区别。
使⽤多线程的理由之⼆是线程间⽅便的通信机制。
对不同进程来说，它们具有独⽴的数据空间，要进⾏数据的传递只能通过通信的⽅式进⾏，这种⽅式不仅费时，⽽且很不⽅便。
线程则不然，由于同⼀进程下的线程之间共享数据空间，所以⼀个线程的数据可以直接为其它线程所⽤，这不仅快捷，⽽且⽅便。
当然，数据的共享也带来其他⼀些问题，有的变量不能同时被两个线程所修改，有的⼦程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地⽅。
除了以上所说的优点外，不和进程⽐较，多线程程序作为⼀种多任务、并发的⼯作⽅式，当然有以下的优点： 1) 提⾼应⽤程序响应。
Linux中多线程详解及简单实例Linux中多线程详解及简单实例1.概念进程：运⾏中的程序。
线程：⼀个程序中的多个执⾏路径。
更准确的定义是：线程是⼀个进程内部的⼀个控制序列。
2.为什么要有线程？⽤fork调⽤进程代价太⾼，需要让⼀个进程同时做多件事情，线程就⾮常有⽤。
3.线程的优点和缺点。
优点：（1）有时，让程序看起来是在同时做两件事是⾮常有⽤的。
⽐如在编辑⽂档时，还能统计⽂档⾥的单词个数。
（2）⼀个混杂着输⼊、计算、输出的程序，利⽤线程可以将这3个部分分成3个线程来执⾏，从⽽改变程序执⾏的性能。
（3）⼀般来说，线程之间切换需要操作系统所做的⼯作⽐进程间切换需要的代价⼩。
缺点：（1）编写线程需要⾮常仔细的设计。
（2）对多线程的调试困难程度⽐单线程调试⼤得多。
4.创建线程#include <pthread.h>（1）int pthread_create(pthread_t *thread,pthread_attr_t *attr,void *(*start_routine)(void *),void *arg);pthread_t pthread_self(void);（2）int pthread_equal(pthread_t thread1,pthread_t thread2);（3）int pthread_once(pthread_once_t *once_control,void(*init_routine)(void));Linux系统⽀持POSIX多线程接⼝，称为pthread。
编写linux下的多线程程序，需要包含头⽂件pthread.h，链接时需要使⽤库libpthread.a。
如果在主线程⾥⾯创建线程，程序就会在创建线程的地⽅产⽣分⽀，变成两个部分执⾏。
线程的创建通过函数pthread_create来完成。
成功返回0。
1.线程创建：int pthread_create(pthread_t thread,pthread_attr_t *attr,void (start_routine)(void ),void *arg);pthread_t pthread_self(void);参数说明：thread：指向pthread_create类型的指针，⽤于引⽤新创建的线程。
