下载文档原格式
第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操作系统定制安装实验地点博学楼实验时间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多线程编程（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篇）第一篇：嵌入式实习报告一、嵌入式系统开发与应用概述在今日，嵌入式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中；通过实验掌握液晶显示文本及图形的方法与程序设计。
第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高级系统编程》教学教案一、教学目标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实验报告题目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();}}/* 让用户选择杀死哪个进程。
中南大学Linux操作系统实验报告学生姓名学院信息科学与工程学院指导老师胡小龙专业班级完成时间目录1.实验一Linux的安装 (3)1.1 实验目的 (3)1.2 实验设备 (3)1.3 实验原理 (3)1.4 实验步骤 (3)2. 实验二Linux基本操作 (5)2.1 实验目的 (5)2.2 实验设备 (5)2.3 实验原理 (6)2.4 实验步骤 (6)3. 实验三Linux系统管理 (10)3.1 实验目的 (10)3.2 实验设备 (10)3.3 实验原理 (10)3.4 实验步骤 (11)4. 实验四Linux Shell程序设计 (14)4.1 实验目的 (14)4.2 实验设备 (14)4.3 实验原理 (15)4.4 实验步骤 (17)5. 实验五Linux 高级程序设计 (20)5.1 实验目的 (20)5.2 实验设备 (21)5.3 实验原理 (21)5.4 实验步骤 (21)6. 实验六Linux内核 (23)6.1 实验目的 (23)6.2 实验设备 (23)6.3 实验原理 (23)6.4 实验步骤 (23)Linux操作系统1.实验一Linux的安装1.1 实验目的（1）了解硬盘分区的概念和方法；（2）掌握硬盘的分区规划；（3）掌握Linux操作系统的安装和配置过程。
1.2 实验设备一台pc机、RedHat Linux 7.2以上版本、VMware Workstation v5.5。
1.3 实验原理Linux可以以多种方式安装在PC机上：(1)独立分区安装、(2)DOS分区安装和(3)虚拟机VMWare下安装。
鉴于VMware下安装对原来系统影响较小且不影响本实验目的，因此采用VMWare下安装方式。
1.4 实验步骤（1）在Windows XP下安装VMware 5.5（2）配置虚拟机（3）启动虚拟机（4）启动Linux安装过程（5）安装过程配置（6）安装后配置（7）第1次启动VMWare下Linux操作系统2.实验二Linux基本操作2.1 实验目的（1）复习Linux基本命令；（2）掌握常用Linux命令。
实验二、嵌入式Linux多线程编程实验一、实验目的1. 熟悉线程的定义、创建及应用方法，掌握编译源代码时引入线程库的方法。
2. 掌握如何利用信号量完成线程间的同步与互斥。
3. 熟悉Makefile工作原理，掌握编写Makefile的编写方法。
二、实验基本要求1. 掌握熟悉线程的定义及操作方法。
2. 利用信号量的PV操作完成完成以下单个生产者和单个消费者模型的代码。
3. 编写在Ubuntu中编译执行的makefile文件，然后在Ubuntu中执行。
4. 编写在实验箱中编译执行的makefile文件，然后在实验箱中执行。
注意Makefile编写规范缩进应使用制表键即Tab键。
三、实验原理1．Linux线程的定义线程（thread）是在共享内存空间中并发的多道执行路径，它们共享一个进程的资源，如文件描述和信号处理。
在两个普通进程（非线程）间进行切换时，内核准备从一个进程的上下文切换到另一个进程的上下文要花费很大的开销。
这里上下文切换的主要任务是保存老进程CPU状态并加载新进程的保存状态，用新进程的内存映像替换进程的内存映像。
线程允许你的进程在几个正在运行的任务之间进行切换，而不必执行前面提到的完整的上下文。
另外本文介绍的线程是针对POSIX线程，也就是pthread。
也因为Linux对它的支持最好。
相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
在串行程序基础上引入线程和进程是为了提高程序的并发度，从而提高程序运行效率和响应时间。
也可以将线程和轻量级进程（LWP）视为等同的，但其实在不同的系统/实现中有不同的解释，LWP更恰当的解释为一个虚拟CPU或内核的线程。
它可以帮助用户态线程实现一些特殊的功能。
Pthread是一种标准化模型，它用来把一个程序分成一组能够同时执行的任务。
2. 什么场合会使用Pthread即线程(1) 在返回前阻塞的I/O任务能够使用一个线程处理I/O，同时继续执行其他处理任务。
北邮嵌入式系统设计实验-实验报告嵌入式试验报告学院：xxx班级：xxx学号：xxx姓名：xxx成员：xxx一、基础学问部分1.多线程试验本章主要讲解线程的概念和线程间的同步方式。
试验一主要介绍线程的概念和线程的创建，试验二、试验三、试验四分离介绍了信号量、互斥锁、条件变量的作用和使用。
1.1 线程的介绍线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。
线程是程序中一个单一的挨次控制流程。
进程内一个相对自立的、可调度的执行单元，是系统自立调度和分派CPU 的基本单位指运行中的程序的调度单位。
在单个程序中同时运行多个线程完成不同的工作，称为多线程。
线程是允许应用程序并发执行多个任务的一种机制，是程序运行后的任务处理单元，也是SylixOS操作系统任务调度的最小单元。
在多核CPU中，同时可以有多个线程在执行，实现真正意义上的并行处理。
线程入口函数是一个能够完成特定任务的函数，因此线程入口函数的编写上与一般函数没有太多区分。
线程的创建函数如下：●创建线程失败，函数返回非0的错误代码，胜利返回0；●*thread pthread_t类型的缓冲区，保存一个线程的线程ID；●*attr 设置线程属性，设置为NULL标识创建的新线程使用默认属性；●*(*start_routine) 线程入口函数函数名●*arg 向所创建线程传入的参数1.2 信号量的概念信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。
在进入一个关键代码段之前，线程必需猎取一个信号量；一旦该关键代码段完成了，那么该线程必需释放信号量。
其它想进入该关键代码段的线程必需等待直到第一个线程释放信号量。
信号量是一个在进程和线程中都可以使用的同步机制。
信号量类似于一个通知，某个线程发出一个通知，等待此通知的线程收到通知后，会执行预先设置的工作。
一、实验目的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函数设置线程的调度策略和优先级。
一、实验目的1. 理解多线程的概念及其在程序设计中的应用。
2. 掌握在Java中创建和使用线程的基本方法。
3. 学习线程的同步和互斥机制，理解死锁、线程安全等概念。
4. 了解线程的生命周期及其状态转换。
二、实验环境- 操作系统：Windows 10- 开发工具：Eclipse IDE- 编程语言：Java三、实验内容本次实验主要围绕以下内容展开：1. 线程的基本操作：创建线程、启动线程、线程的执行、线程的终止。
2. 线程的同步与互斥：使用synchronized关键字实现线程同步，防止数据竞态。
3. 线程的通信：使用wait()、notify()、notifyAll()方法实现线程间的通信。
4. 线程池：使用ExecutorService创建线程池，提高线程复用率。
5. 线程的生命周期：观察线程的状态转换，理解线程的创建、运行、阻塞、终止等过程。
四、实验步骤1. 创建线程：- 通过继承Thread类创建线程，并重写run()方法。
- 通过实现Runnable接口创建线程，将任务封装在Runnable对象中。
- 使用匿名内部类创建线程。
2. 线程的同步与互斥：- 使用synchronized关键字对共享资源进行加锁，保证同一时间只有一个线程可以访问。
- 使用ReentrantLock类实现线程同步，提供更丰富的锁操作。
3. 线程的通信：- 使用wait()、notify()、notifyAll()方法实现线程间的通信，解决生产者-消费者问题。
4. 线程池：- 使用ExecutorService创建线程池，提高线程复用率。
- 使用Future接口获取线程执行结果。
5. 线程的生命周期：- 使用Thread类的方法观察线程的状态，如isAlive()、getState()等。
五、实验结果与分析1. 创建线程：- 通过继承Thread类、实现Runnable接口和匿名内部类成功创建了线程，并观察到线程的执行。
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），是一个多线程同步问题的经典案例。
一、实验目的1. 理解进程的概念及其在操作系统中的作用。
2. 掌握进程创建和撤销的基本原理和方法。
3. 通过实验加深对进程管理机制的理解。
二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 编译器：GCC三、实验原理在操作系统中，进程是系统进行资源分配和调度的基本单位。
进程创建是指从无到有地创建一个新的进程，而进程撤销则是指结束一个进程的生命周期。
进程创建和撤销是操作系统进程管理中的重要操作。
四、实验内容1. 进程创建实验2. 进程撤销实验五、实验步骤1. 进程创建实验（1）创建一个新进程```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>int main() {pid_t pid = fork(); // 创建子进程if (pid == -1) {perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process: PID = %d\n", getpid());// 执行子进程的任务} else {// 父进程printf("Parent process: PID = %d\n", getpid());// 等待子进程结束wait(NULL);}return 0;}```（2）编译并运行程序```bashgcc -o process_create process_create.c./process_create```（3）观察输出结果在控制台会看到两个进程的PID，其中一个为父进程，另一个为子进程。
2. 进程撤销实验（1）创建一个新进程```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid = fork(); // 创建子进程if (pid == -1) {perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process: PID = %d\n", getpid()); // 执行子进程的任务sleep(10); // 子进程睡眠10秒} else {// 父进程printf("Parent process: PID = %d\n", getpid()); // 等待子进程结束wait(NULL);}return 0;}```（2）编译并运行程序```bashgcc -o process_destroy process_destroy.c./process_destroy```（3）观察输出结果在控制台会看到两个进程的PID，父进程会等待子进程结束。
实验七：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例子，并运行查看结果，然后和前面两个例子比较查看系统资源的差异。
