实验七：Linux多线程编程(实验报告)
多线程程序实验报告(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. 使用线程通信机制实现线程间的协作。
理工大学Linux实验报告
实验名称实验一Linux操作系统定制安装实验地点博学楼实验时间4月16日网络实验室一、实验目的和要求⑴通过对Linux 操作系统的定制安装，建立对Linux操作系统的初步认识，为后续实验的进行提供基础平台。
⑵掌握Linux操作系统的虚拟机定制安装。
⑶熟悉Linux文件目录结构二、实验内容和原理实验内容：利用虚拟机软件定制安装Linux操作系统，熟悉安装过程中各个选项的意义。
实验原理：虚拟机可以说是一种软件，也可以说是一种技术，它允许用户在一台主机上虚拟出多台计算机，每台虚拟的计算机都可以有自己的硬件及软件配置。
三、主要仪器设备PC机、VMware Player、Redhat/Ubuntu/Fedora四、操作方法与实验步骤⑴安装VMware Player⑵在VMware Player当中创建一个新的虚拟机，指定安装包的路径。
⑶安装定制Redhat Enterprise Linux 5.0说明：⑴对软件开发和和网络服务包进行定制。
⑵选择samba服务、nfs服务、tftp服务、Telnet服务和FTP服务⑶关闭系统防火墙、禁用SELinux服务。
⑷手动设置系统分区。
五、实验数据记录和处理1、安装Ubuntu进入界面：2、选择tftp服务3、对软件开发和网络服务包进行定制，都选择老的软件开发和老的网络服务器4、关闭系统防火网5、禁用SELinux服务六、实验结果与分析七、讨论、心得通过这次实验，在自己电脑的虚拟机上安装好了Ubuntu的镜像文件，并在Ubuntu下写了一些简单的命令，深深地感觉在虚拟机上运行Ubuntu远远要比双系统下方便得多，尤其是在两种不同系统下来回切换。
由于电脑上之前就已经安装过虚拟机，所以，实验报告中未对虚拟机的安装加以赘述。
实验名称实验二熟悉Linux系统的基本命令实验时间4月18日实验地点博学楼网络实验室一、实验目的和要求⑴熟悉Linux命令格式⑵学会如何获取命令帮助信息⑶熟练掌握Linux常用命令⑷掌握GCC命令的使用及其常用参数的含义二、实验内容和原理实验内容：系统设置命令、文件及文件夹操作命令、压缩与解压缩命令、自动补全与历史命令、管道与重定向命令、GCC命令的使用三、主要仪器设备PC机、装有Linux操作系统的虚拟机四、操作方法与实验步骤⑴练习以下常用命令的使用shutdown、reboot、logout、exit、useradd、userdel、su、cd、ls、touch、mkdir、cp、rm、rmdir、mv、more、less、man、du、find、clear、grep、cat、history、tar、unzip、chmod、管道命令|以及重定向命令⑵举例说明管道命令| 的使用⑶举例说明重定向命令<、<<、>、>>的使用⑷编写一个C的源程序，并用gcc进行编译，练习使用gcc的各个参数，理解参数的意义五、实验数据记录和处理1.cd、ls 、mkdir 新建hello文件夹2.cp 复制a到hello文件夹3.rm移除hello 中的a文件4.rmdir移除hello文件夹5.mv更改文件名字、移动文件6.du -b 以字节为单位显示cache目录的大小7.find / -name lolo搜索当前目录下名为lolo的文件8.grep 在lan/b.txt文件里查找字符3，并输出行号-n；输出b.txt内容9.grep重定向追加>>六、讨论、心得本次实验室是熟悉Linux的基本操作命令。
实验七：Linux多线程编程(实验报告)
实验七：Linux多线程编程（4课时）实验目的：掌握线程的概念；熟悉Linux下线程程序编译的过程；掌握多线程程序编写方法。
实验原理：为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。
1 多线程概念使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。
运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间。
使用多线程的理由之二是线程间方便的通信机制。
同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。
2多线程编程函数Linux系统下的多线程遵循POSIX线程接口，称为pthread。
编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。
pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义：typedef unsigned long int pthread_t; 它是一个线程的标识符。
函数pthread_create用来创建一个线程，它的原型为：extern int pthread_create((pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg));第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
函数pthread_join用来等待一个线程的结束。
函数原型为：extern int pthread_join(pthread_t th, void **thread_return);第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。
操作系统实验(进程)多线程实现矩阵乘法
多线程编程实现矩阵乘法
一、实验目的
通过实验，熟悉基于Win32线程库和Pthread线程库的编程环境，掌握利用Windows API和Pthread API进行多线程编程的方法，进一步加深对线程概念以及多线程编程相关事项的理解。
二、实验内容
1. 在Windows操作系统上，利用Windows API编写应用程序实现矩阵乘法。
2. 在Linux操作系统上，利用Pthread API编写应用程序实现矩阵乘法。
3. 在上述两种环境下，实现相乘操作的两个矩阵均作为应用程序的输入参数动态生成，并输出计算结果。
4. 在程序实现过程中，要求每个乘积矩阵元素的计算过程均由一个独立的线程实现。
三、实验步骤
1、windows上：打开codeblocks IDE，创建新C++项目，在新文件中输入如下代码，并编译运行。
2、linux上
打开gedit输入下面的代码，保存为Thread.c，在终端进入文档保存的目录并输入
gcc –c Thread.c
gcc –o Thread Thread.o –lpthread
./Thread 得到输出结果。
四、程序运行时的初值和运行结果
1、在Windows操作系统上，利用Windows API实现矩阵乘法，程序运行结果
2. 在Linux操作系统上，利用Pthread API实现矩阵乘法程序运行结果
Pthread_create()
第一个参数为指向线程标识符的指针。
第二个参数用来设置线程属性。
第三个参数是线程运行函数的起始地址。
最后一个参数是运行函数的参数。
嵌入式实习报告（共5篇）
嵌入式实习报告（共5篇）第一篇：嵌入式实习报告一、嵌入式系统开发与应用概述在今日，嵌入式ARM 技术已经成为了一门比较热门的学科，无论是在电子类的什么领域，你都可以看到嵌入式ARM 的影子。
如果你还停留在单片机级别的学习，那么实际上你已经落下时代脚步了，ARM 嵌入式技术正以几何的倍数高速发展，它几乎渗透到了几乎你所想到的领域。
本章节就是将你领入ARM 的学习大门，开始嵌入式开发之旅。
以嵌入式计算机为技术核心的嵌入式系统是继网络技术之后，又一个IT领域新的技术发展方向。
由于嵌入式系统具有体积小、性能强、功耗低、可靠性高以及面向行业具体应用等突出特征，目前已经广泛地应用于军事国防、消费电子、信息家电、网络通信、工业控制等各个领域。
嵌入式的广泛应用可以说是无所不在。
嵌入式微处理器技术的基础是通用计算机技术。
现在许多嵌入式处理器也是从早期的PC 机的应用发展演化过来的，如早期PC 诸如TRS-80、Apple II 和所用的Z80 和6502 处理器，至今仍为低端的嵌入式应用。
在应用中，嵌入式微处理器具有体积小、重量轻、成本低、可靠性高的优点。
嵌入式处理器目前主要有Am186/88、386EX、SC-400、Power PC、68000、MIPS、ARM 等系列。
在早期实际的嵌入式应用中，芯片选择时往往以某一种微处理器内核为核心，在芯片内部集成必要的ROM/EPROM/Flash/EEPROM、SRAM、接口总线及总线控制逻辑、定时/计数器、WatchDog、I/O、串行口、脉宽调制输出、A/D、D/A 等各种必要的功能和外设。
二、实习设备硬件：Embest EduKit-IV实验平台、ULINK2仿真器套件、PC机软件：μVision IDE for ARM集成开发环境、Windows 98/2000/NT/XP三、实习目的1.初步掌握液晶屏的使用及其电路设计方法；掌握S3C2410X处理器的LCD控制器的使用；掌握通过任务调用的方法把液晶显示函数添加到uC/OS-II中；通过实验掌握液晶显示文本及图形的方法与程序设计。
建立线程的实验报告(3篇)
第1篇一、实验目的1. 理解线程的概念和作用；2. 掌握在C++中创建和使用线程的方法；3. 了解线程同步机制，如互斥锁、条件变量等；4. 分析线程间的通信和协作。
二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 编程语言：C++三、实验内容本次实验主要分为以下几个部分：1. 线程的基本概念和作用；2. 创建和使用线程；3. 线程同步机制；4. 线程间的通信和协作。
四、实验步骤1. 线程的基本概念和作用线程是程序执行过程中的一个独立单位，它包含程序执行所需的基本信息，如程序计数器、寄存器等。
线程的主要作用是提高程序的执行效率，实现并发执行。
2. 创建和使用线程在C++中，可以使用`std::thread`类来创建线程。
以下是一个简单的例子：```cppinclude <iostream>void printNumber(int n) {for (int i = 0; i < n; ++i) {std::cout << i << std::endl;}}int main() {std::thread t1(printNumber, 10); // 创建线程，传入函数和参数std::thread t2(printNumber, 20);t1.join(); // 等待线程t1执行完毕t2.join(); // 等待线程t2执行完毕return 0;}```在上面的代码中，我们创建了两个线程`t1`和`t2`，分别执行`printNumber`函数。
使用`join`函数可以等待线程执行完毕。
3. 线程同步机制线程同步机制用于解决多线程在执行过程中可能出现的数据竞争、死锁等问题。
以下是一些常用的线程同步机制：（1）互斥锁（Mutex）互斥锁用于保护共享资源，确保同一时刻只有一个线程可以访问该资源。
以下是一个使用互斥锁的例子：```cppinclude <iostream>include <mutex>std::mutex mtx;void printNumber(int n) {mtx.lock(); // 获取互斥锁for (int i = 0; i < n; ++i) {std::cout << i << std::endl;}mtx.unlock(); // 释放互斥锁}int main() {std::thread t1(printNumber, 10);std::thread t2(printNumber, 20);t1.join();t2.join();return 0;}```（2）条件变量（Condition Variable）条件变量用于在线程间实现等待和通知机制。
《Linux高级系统编程》教学教案
《Linux高级系统编程》教学教案一、教学目标1. 让学生掌握Linux系统编程的基本概念和原理。
2. 培养学生熟练使用Linux系统编程API的能力。
3. 使学生了解Linux系统编程的高级主题和技巧。
4. 培养学生解决实际问题的能力，提高他们在Linux环境下的软件开发水平。
二、教学内容1. Linux系统编程概述讲解Linux系统编程的基本概念、特点和优势。
2. 文件I/O操作介绍Linux文件I/O模型，讲解文件的打开、关闭、读写、同步等操作。
3. 进程管理讲解Linux进程的概念、创建、终止、进程间通信等知识。
4. 线程管理介绍Linux线程的基本概念、创建、同步、互斥等知识。
5. 高级I/O操作讲解Linux高级I/O操作，如异步I/O、直接I/O、内存映射I/O等。
三、教学方法1. 讲授法：讲解基本概念、原理和知识点。
2. 案例教学法：通过实际案例让学生掌握编程技巧和方法。
3. 实验教学法：安排实验课程，让学生亲自动手实践，提高实际操作能力。
四、教学环境1. 教室环境：投影仪、计算机、网络等。
2. 实验环境：装有Linux操作系统的计算机、网络等。
五、教学评估1. 课堂问答：检查学生对课堂知识的理解和掌握程度。
2. 实验报告：评估学生在实验过程中的动手能力和解决问题能力。
3. 课程作业：检查学生对课程知识点的综合运用能力。
4. 期末考试：全面评估学生对本门课程的掌握程度。
六、信号处理1. 信号基本概念讲解信号的定义、作用和信号处理的基本方法。
2. 信号处理函数介绍Linux信号处理函数，如signal(), rse(), sigaction()等。
3. 信号在进程和线程中的处理讲解信号在进程和线程中的传播和处理机制。
七、同步与互斥1. 同步与互斥基本概念讲解同步与互斥的概念、作用和应用场景。
2. 互斥锁介绍Linux互斥锁的使用，如pthread_mutex_lock(), pthread_mutex_unlock()等。
linux进程线程管理实验报告
linux进程线程管理实验报告————————————————————————————————作者：————————————————————————————————日期：西安郵電學院操作系统LINUX实验报告题目1：进程______题目2：线程管理__题目3：互斥_____系部名称：计算机学院专业名称：软件工程班级：0802学号：04085048学生姓名：郭爽乐时间：2010-10-31实验一: 进程管理一．实验目的通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握在POSIX 规范中fork和kill系统调用的功能和使用。
二．实验要求2.1 实验环境要求1. 硬件(1) 主机：Pentium III 以上；(2) 内存：128MB 以上；(3) 显示器：VGA 或更高；(4) 硬盘空间：至少100MB 以上剩余空间。
2. 软件Linux 操作系统，内核2.4.26 以上，预装有X-Window 、vi、gcc、gdb 和任意web 浏览器。
2.2 实验前的准备工作学习man 命令的用法，通过它查看fork 和kill 系统调用的在线帮助，并阅读参考资料，学会fork 与kill 的用法。
复习C 语言的相关内容。
三、实验内容3.1 补充POSIX 下进程控制的残缺版实验程序3.2回答下列问题：1. 你最初认为运行结果会怎么样？2. 实际的结果什么样？有什么特点？试对产生该现象的原因进行分析。
3. proc_number 这个全局变量在各个子进程里的值相同吗？为什么？4. kill 命令在程序中使用了几次？每次的作用是什么？执行后的现象是什么？5. 使用kill 命令可以在进程的外部杀死进程。
进程怎样能主动退出？这两种退出方式哪种更好一些？四、实验结果4.1 补充完全的源程序#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<signal.h>#include<ctype.h>#define MAX_CHILD_NUMBER 10/* 允许建立的子进程个数最大值 */ #define SLEEP_INTERV AL 1/* 子进程睡眠时间 */int proc_number=0; /* 子进程的编号，从0开始 */void do_something();main(int argc,char *argv[]){int child_proc_number=MAX_CHILD_NUMBER; /* 子进程个数 */ int i,ch;pid_t child_pid;pid_t pid[10]={0};/* 存放每个子进程的id */if(argc>1){child_proc_number=atoi(argv[1]);child_proc_number=(child_proc_number>10)?10:child_proc_number; /* 命令行参数中的第一个参数表示建立几个子进程，最多10个 */ }/*建立child_proc_number个子进程* 子进程要执行* proc_number = i;* do_something();* 父进程把子进程的id保存到pid[i] */for(i=0;i<child_proc_number;i++){child_pid=fork();if(child_pid== -1){perror("creat error!\n");return 1;}else if(child_pid>0)pid[i]=child_pid;else{proc_number=i;do_something();}}/* 让用户选择杀死哪个进程。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验七：Linux多线程编程（4课时）实验目的：掌握线程的概念；熟悉Linux下线程程序编译的过程；掌握多线程程序编写方法。
实验原理：为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。
1 多线程概念使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。
运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间。
使用多线程的理由之二是线程间方便的通信机制。
同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。
2多线程编程函数Linux系统下的多线程遵循POSIX线程接口，称为pthread。
编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。
pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义：typedef unsigned long int pthread_t; 它是一个线程的标识符。
函数pthread_create用来创建一个线程，它的原型为：extern int pthread_create((pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg));第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
函数pthread_join用来等待一个线程的结束。
函数原型为：extern int pthread_join(pthread_t th, void **thread_return);第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。
函数pthread_exit的函数原型为：extern void pthread_exit(void *retval);唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。
3 修改线程的属性线程属性结构为pthread_attr_t，它在头文件/usr/include/pthread.h中定义。
属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。
设置线程绑定状态的函数为pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS （非绑定的）。
另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。
用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。
4 线程的数据处理和进程相比，线程的最大优点之一是数据的共享性，各个进程共享父进程处沿袭的数据段，可以方便的获得、修改数据。
但这也给多线程编程带来了许多问题。
我们必须当心有多个不同的进程访问相同的变量。
许多函数是不可重入的，即同时不能运行一个函数的多个拷贝（除非使用不同的数据段）。
在函数中声明的静态变量常常带来问题，函数的返回值也会有问题。
互斥锁互斥锁用来保证一段时间内只有一个线程在执行一段代码。
必要性显而易见：假设各个线程向同一个文件顺序写入数据，最后得到的结果一定是灾难性的。
条件变量互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。
而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。
使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。
信号量信号量既可以作为二值计数器(即0,1),也可以作为资源计数器.信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。
当公共资源增加时，调用函数sem_post（）增加信号量。
只有当信号量值大于０时，才能使用公共资源，使用后，函数sem_wait（）减少信号量。
函数sem_trywait（）和函数pthread_ mutex_trylock（）起同样的作用，它是函数sem_wait（）的非阻塞版本。
实验内容：线程函数编译时需要添加特殊编译选项：gcc *.c -lpthread -o 1、完成教材上thread.c的例子，想一下每次执行时结果相同吗，为什么？答：每个线程的运行和结束时无序的、独立与并行的。
实验代码：/* thread.c */#include <stdio.h>#include <stdlib.h>#include <pthread.h>#define THREAD_NUMBER 3 /*线程数*/#define REPEAT_NUMBER 5 /*每个线程中的小任务数*/#define DELAY_TIME_LEVELS 6.0 /*小任务之间的最大时间间隔*/void *thrd_func(void *arg) //指针好乱，这里看不懂定义了什么，求解释//定义了一个返回值为指向空类型的指针的函数，该函数的参数为一个指针{ /* 线程函数例程*/int thrd_num = (int)arg; //这个是赋值吗？看不懂，求解释//定义了一个整型参数，取值为argint delay_time = 0;int count = 0;printf("Thread %d is starting\n", thrd_num);for (count = 0; count < REPEAT_NUMBER; count++){delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;printf("\tThread %d: job %d delay = %d\n",thrd_num, count, delay_time);sleep(delay_time); //暂停？秒//暂停随机秒}//\t 输出一个T ab 占8列//输出格式：Thread thrd_num: job count delay = delay_time 回车printf("Thread %d finished\n", thrd_num);//输出格式：Thread thrd_num finished 回车pthread_exit(NULL);}int main(void){pthread_t thread[THREAD_NUMBER];//定义了一个类型为pthread_t的数组，数组元素的个数为3int no = 0, res;void * thrd_ret; //这句什么意思？求解释//定义了一个指针，指向哪里后面的程序里有。
srand(time(NULL)); //这句什么意思？求解释//用系统时间计算一个随机数。
for (no = 0; no < THREAD_NUMBER; no++){/* 创建多线程*/res = pthread_create(&thread[no], NULL, thrd_func, (void*)no); //&thread[no]线程标识符//pthread_create函数的参数含义请看书。
if (res != 0) //创建线程出错时res=错误码{printf("Create thread %d failed\n", no);exit(res);//上面的不是退出进程，而是判断pthread_create（）函数是否成功执行。
}}printf("Create treads success\n Waiting for threads to finish...\n");//如果上面没退出进程，则创建线程成功for (no = 0; no < THREAD_NUMBER; no++){/* 等待线程结束*/res = pthread_join(thread[no], &thrd_ret);// thread[no]线程标识符，此例总共有thread[0]，thread[1]，thread[2]，3个线程//请看书上pthread_join （）函数的参数含义。
if (!res) //res=0时，挂起线程成功//res=0时，说明pthread_join（）函数执行成功。
{printf("Thread %d joined\n", no);}else{printf("Thread %d join failed\n", no);}}return 0;}2、完成教材上thread_mutex.c例，查看运行情况。
和上例比较有何不同，想一下为什么会出现这种差异？答：这里3个线程之间的运行顺序跟创建线程的顺序相同。
#include <stdio.h>#include <stdlib.h>#include <pthread.h>#define THREAD_NUM 3 /* 线程数*/#define REPEAT_NUM 3 /* 每个线程的小任务数*/#define DELAY_TIME_LEVELS 6.0 /*小任务之间的最大时间间隔*/pthread_mutex_t mutex;void *thrd_func(void *arg){int thrd_num = (int)arg;int delay_time = 0, count = 0;int res;/* 互斥锁上锁*/res = pthread_mutex_lock(&mutex);if(res){printf("Thread %d lock failed\n", thrd_num);pthread_exit(NULL);}printf("Thread %d is starting\n", thrd_num);for(count = 0; count < REPEAT_NUM;count++){delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;sleep(delay_time);printf("\tThread %d: job %d delay = %d\n",thrd_num, count, delay_time);}printf("Thread %d finished\n", thrd_num);pthread_mutex_unlock(&mutex);pthread_exit(NULL);}int main(void) {pthread_t thread[THREAD_NUM];int no = 0, res;void * thrd_ret;srand(time(NULL));/* 互斥锁初始化*/pthread_mutex_init(&mutex, NULL);for (no = 0; no < THREAD_NUM; no++){res = pthread_create(&thread[no], NULL, thrd_func, (void*)no);if (res != 0){printf("Create thread %d failed\n", no);exit(res);}}printf("Create treads success \n Waiting for threads to finish...\n");for(no=0; no<THREAD_NUM;no++){res = pthread_join(thread[no],&thrd_ret);if(!res){printf("Thread %d joined\n",no);}else{printf("Thread %d join failed\n",no);}}pthread_mutex_destroy(&mutex);return 0;}3、完成教材上thread_attr.c例子，并运行查看结果，然后和前面两个例子比较查看系统资源的差异。