Linux 多进程程序设计
linux程序设计课程设计
linux程序设计课程设计一、教学目标本课程的教学目标是使学生掌握Linux程序设计的基本概念、原理和方法，培养学生具备运用Linux编程语言进行程序设计的能力。
具体目标如下：1.知识目标：（1）了解Linux操作系统的基本原理和架构；（2）掌握Linux编程环境及其常用开发工具；（3）熟悉C语言在Linux环境下的编程方法；（4）理解进程管理、内存管理、文件系统等Linux核心概念；（5）学习常用的Linux系统调用和库函数。
2.技能目标：（1）能够使用Linux命令行进行基本操作；（2）掌握在Linux环境下使用C语言进行程序设计；（3）具备阅读和理解Linux系统源代码的能力；（4）学会使用Git等版本控制工具进行代码管理；（5）能够独立调试和优化Linux程序。
3.情感态度价值观目标：（1）培养学生对Linux操作系统的兴趣和好奇心；（2）培养学生团队合作精神和自主学习能力；（3）培养学生遵循编程规范和代码优化的意识；（4）培养学生具备良好的编程习惯和道德素养。
二、教学内容本课程的教学内容主要包括以下几个部分：1.Linux操作系统概述：介绍Linux的发展历程、内核架构以及常见的Linux发行版；2.Linux编程环境：学习如何在Linux环境下安装和配置开发工具，如GCC、GDB、Make等；3.C语言基础：复习C语言的基本语法、数据类型、运算符、表达式等；4.进程管理：学习进程的概念、进程控制块、进程状态转换、进程同步与互斥等；5.内存管理：了解内存分配与回收机制、内存保护、虚拟内存等；6.文件系统：学习文件和目录的概念、文件权限、文件操作函数、文件I/O等；7.系统调用与库函数：掌握常用的系统调用和库函数，如标准库函数、进程控制函数、文件操作函数等；8.编程实践：通过实际项目练习，培养学生具备独立编写和调试Linux程序的能力。
三、教学方法本课程采用多种教学方法相结合，以提高学生的学习兴趣和主动性：1.讲授法：讲解Linux操作系统的基本原理、核心概念和编程方法；2.讨论法：学生针对实际问题进行讨论，培养学生的思考和表达能力；3.案例分析法：分析典型的Linux程序设计案例，让学生了解实际应用场景；4.实验法：安排实验课程，让学生动手实践，巩固所学知识。
Linux多进程
LINUX进程控制课程内容linux下进程的创建、终止、控制；进程间资源的继承；多进程间的通讯；守护进程。
目录1. Linux进程概述 (1)1.1. 进程标识 (2)1.2. 进程的用户ID与组ID(进程的运行身份) (2)2. 进程的创建 (3)2.1. system函数 (4)2.2. fork函数 (4)2.3. exec函数族 (5)2.4. popen函数 (6)3. 进程控制与终止 (8)3.1. 进程的控制 (8)3.2. 进程的终止 (9)4. 进程间打开文件的继承 (9)4.1. 用fork继承打开的文件 (9)4.2. 用exec*继承打开的文件 (10)4.3. 用管道(FIFO)传递打开的文件的信息 (11)5. 进程间通信(Interprocess Communication,IPC) (13)5.1. 无名管道(PIPE) (13)5.2. 命名管道(FIFO) (15)5.3. 共享内存 (18)5.4. 消息队列 (20)6. 守护进程(Daemon) (24)1.Linux进程概述进程是程序的执行实例，它是Linux的基本调度单位。
一个进程由如下元素组成：●程序的当前上下文，即程序的当前执行状态；●程序的当前执行目录●程序访问的文件和目录●程序的访问权限，比如它的文件模式和所有权●内存和其他分配给进程的系统资源内核使用进程来控制对CPU和其他系统资源的访问，并且使用进程来决定在CPU上运行哪个程序，运行多久以及采用什么特性运行它。
内核的调度器负责在所有的进程间分配CPU执行时间，称为时间片(time slice)，它轮流在每个进程分得的时间片用完后从进程那里抢回控制权。
1.1.进程标识OS会为每个进程分配一个唯一的整型ID，做为进程的标识号(pid)。
进程除了自身的ID外，还有父进程ID(ppid),所有进程的祖先进程是同一个进程，它叫做init进程，ID为1，init进程是内核自举后的一个启动的进程。
linux下的CC++多进程多线程编程实例详解
linux下的CC++多进程多线程编程实例详解linux下的C\C++多进程多线程编程实例详解1、多进程编程#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main(){pid_t child_pid;/* 创建⼀个⼦进程 */child_pid = fork();if(child_pid == 0){printf("child pid\n");exit(0);}else{printf("father pid\n");sleep(60);}return 0;}2、多线程编程#include <stdio.h>#include <pthread.h>struct char_print_params{char character;int count;};void *char_print(void *parameters){struct char_print_params *p = (struct char_print_params *)parameters;int i;for(i = 0; i < p->count; i++){fputc(p->character,stderr);}return NULL;}int main(){pthread_t thread1_id;pthread_t thread2_id;struct char_print_params thread1_args;struct char_print_params thread2_args;thread1_args.character = 'x';thread1_args.count = 3000;pthread_create(&thread1_id, NULL, &char_print, &thread1_args);thread2_args.character = 'o';thread2_args.count = 2000;pthread_create(&thread2_id, NULL, &char_print, &thread2_args);pthread_join(thread1_id, NULL);pthread_join(thread2_id, NULL);return 0;}3、线程同步与互斥1）、互斥pthread_mutex_t mutex;pthread_mutex_init(&mutex, NULL);/*也可以⽤下⾯的⽅式初始化*/pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&mutex);/* 互斥 */thread_flag = value;pthread_mutex_unlock(&mutex);2）、条件变量int thread_flag = 0;pthread_mutex_t mutex;pthread_cond_t thread_flag_cv;\void init_flag(){pthread_mutex_init(&mutex, NULL);pthread_cond_init(&thread_flag_cv, NULL);thread_flag = 0;}void *thread_function(void *thread_flag){while(1){pthread_mutex_lock(&mutex);while(thread_flag != 0 ){pthread_cond_wait(&thread_flag_cv, &mutex);}pthread_mutex_unlock(&mutex);do_work();}return NULL;}void set_thread_flag(int flag_value){pthread_mutex_lock(&mutex);thread_flag = flag_value;pthread_cond_signal(&thread_flag_cv);pthread_mutex_unlock(&mutex);}感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。
操作系统：编程模拟多进程共享临界资源linux-c语言
一、课程设计目的本课程设计是学生学习完《计算机操作系统》课程后，进行的一次全面的综合训练，通过课程设计，让学生更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
二、课程设计要求从课程设计的目的出发，通过设计工作的各个环节，达到以下教学要求：每位同学从所给题目中任选一个（如自拟题目，需经教师同意），且必须独立完成课程设计，不能相互抄袭。
设计完成后，将所完成的作品交由老师检查。
要求写出一份详细的设计报告。
三、课程设计题目编程模拟多进程共享临界资源四、课程设计功能和目标1、要求产生至少3个进程：2、两个进程模拟需要进入临界区的用户进程，当需要进入临界区时，显示：“进程x请求进入临界区…”，同时向管理进程提出申请；在临界区中等待一段随机时间，并显示：“进程x正在临界区…”；当时间结束，显示：“进程x退出临界区…”,同时向管理进程提出退出申请。
3、一个进程作为原语级管理进程，接受其他进程的临界区进入请求：如果允许进入，则设置相应变量，然后返回；如果不允许进入，则进入循环等待，直到允许为止；4、对临界区的访问应遵循空闲让进、忙则等待、有限等待、让权等待的准则。
5、进程间通信可以采用信号、消息传递、管道或网络通信方式。
五、课程设计实现原理通过编写，创建两个进程模拟需要进入临界区，另外编写一个进程作为原语的管理进程，其负责两个进程的进入！接着设置一个临界区，让其进程在其中访问遵循空闲让进、忙则等待、有限等待、让权等待的准则。
当进程和临界区建立好后，临界区的数据传输，受到了系统硬件的支持，不耗费多余的资源；而进程间通信传递，由软件进行控制和实现，需要消耗一定的CPU资源。
从这个意义上讲，临界区更适合频繁和大量的数据传输。
进程信息的传递，自身就带有同步的控制。
当等到信息的时候，进程进入睡眠状态，不再消耗CPU资源。
而共享队列如果不借助其他机制进行同步，接收数据的一方必须进行不断的查询，白白浪费了大量的CPU资源。
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 */
第6章 linux进程控制开发及多线程编程
进程的状态
进程是程序的执行过程，根据它的生命周期可以划分成3种 状态。 执行态：该进程正在运行，即进程正在占用CPU。 就绪态：进程已经具备执行的一切条件，正在等待分配 CPU的处理时间片。 等待态：进程不能使用CPU，若等待事件发生（等待的 资源分配到）则可将其唤醒。
Linux下进程地址空间（1）
互斥锁线程控制 （1）
在同一时刻只能有一个线程掌握某个互斥锁，拥有上锁状态 的线程能够对共享资源进行操作。若其他线程希望上锁一个 已经被上锁的互斥锁，则该线程就会挂起，直到上锁的线程 释放掉互斥锁为止。
互斥锁机制主要包括下面的基本函数。 互斥锁初始化： pthread_mutex_init() 互斥锁上锁： pthread_mutex_lock() 互斥锁判断上锁：pthread_mutex_trylock() 互斥锁解锁： pthread_mutex_unlock() 消除互斥锁： pthread_mutex_destroy()
示例
阅读并执行示例7-2-4 开始
教材P216-P217
fork()
程序功能： （1）使用fork创建一个子进程， 然后让其子进程暂停5s（sleep函 数）。 （2）父进程使用waitpid，参数 WNOHANG使进程不会阻塞； （3）若子进程退出，则waitpid返 回子进程号，若没有则waitpid返 回0，并且父进程每隔一秒循环判 断。
因此，可以通过返回值来判定该进程是父进程还是子进程。
fork示例
1.Fork返回两个值返回到哪里？？
int main(void)
{
pid_t result;
2.怎样区分是父、子进程？？
result = fork();
linux编程 实验报告
linux编程实验报告Linux编程实验报告一、引言Linux操作系统是一种自由开源的操作系统，具有稳定性、安全性和灵活性等优点，被广泛应用于服务器、嵌入式系统和个人电脑等领域。
本实验旨在通过编程实践，探索Linux编程的基本概念和技术，并通过实验结果验证相关理论。
二、实验目的本实验的主要目的是通过编写C语言程序，理解Linux系统调用的原理和使用方法。
具体目标包括：1. 熟悉Linux系统调用的概念和基本原理；2. 掌握Linux系统调用的常用函数及其使用方法；3. 理解文件操作、进程管理和网络编程等方面的基本知识。
三、实验环境本实验使用的实验环境为Ubuntu 20.04 LTS操作系统。
在该系统上，我们可以使用gcc编译器编译C语言程序，并通过终端执行程序。
四、实验内容1. 文件操作文件操作是Linux编程中的重要内容之一。
通过使用系统调用函数，我们可以实现对文件的读写、创建和删除等操作。
在本实验中，我们编写了一个简单的文件复制程序，实现将一个文件的内容复制到另一个文件中。
2. 进程管理进程是Linux系统中的基本执行单元。
通过创建和管理进程，我们可以实现并发执行和多任务处理等功能。
在本实验中，我们编写了一个简单的多进程程序，实现同时执行多个任务的效果。
3. 网络编程网络编程是Linux编程中的一个重要领域，它涉及到网络通信、套接字编程和网络协议等内容。
在本实验中，我们编写了一个简单的客户端-服务器程序，实现了基于TCP协议的网络通信。
五、实验结果与分析通过实验，我们成功编写了文件复制程序、多进程程序和客户端-服务器程序，并在实验环境中运行和测试了这些程序。
实验结果表明，我们对Linux编程的基本概念和技术有了初步的理解和掌握。
在文件复制程序中，我们使用了open、read和write等系统调用函数，实现了将源文件的内容复制到目标文件中。
通过实验测试，我们发现该程序能够正确地复制文件，保持了源文件的内容和结构。
linux 中的进程处理和控制方式
linux 中的进程处理和控制方式Linux 是一种广泛使用的操作系统，它具有强大的进程处理和控制功能。
在 Linux 系统中，进程是进行任务的基本单位，它们可以同时运行，互相通信，共享资源，因此进程处理和控制是 Linux 系统重要的组成部分。
Linux 提供了多种方式来处理和控制进程。
以下是一些常见的方式：1. 创建新进程：在 Linux 系统中，可以通过 fork() 系统调用创建一个新的子进程。
子进程是通过复制父进程的内存空间、文件描述符和其他资源来创建的。
这样可以实现并行处理任务，提高系统的效率。
创建新进程时，可以使用 exec() 系统调用来加载一个新的程序运行。
2. 进程调度：Linux 使用调度器（scheduler）来决定哪个进程在何时执行。
调度算法会根据进程的优先级（priority）和调度策略来决定进程的执行顺序。
常见的调度策略包括先进先出（FIFO）、最短作业优先（SJF）、轮转（Round Robin）等。
通过合理的调度算法，可以提高系统的响应速度和资源利用率。
3. 进程间通信：在 Linux 中，进程之间可以通过多种方式进行通信。
其中最常用的方式是通过管道（pipe）、信号（signal）和共享内存（shared memory）来进行进程间的数据交换。
管道可以实现进程的单向通信，信号可以用于进程之间的异步通信，而共享内存可以让多个进程共享同一片内存区域，实现高效的数据交换。
4. 进程控制：Linux 提供了多个命令和系统调用来控制进程的行为。
例如，可以使用 ps 命令来查看系统中正在运行的进程，使用kill 命令发送信号终止进程，使用 nice 命令来改变进程的优先级等。
此外，还可以使用进程控制信号（Process Control Signals）来改变进程的状态，如暂停、继续、停止等。
5. 进程管理工具：Linux 提供了一些进程管理工具来帮助用户更方便地处理和控制进程。
Linux多线程程序设计
创建缺省线程
如果未指定属性对象，则该对象为NULL，系统会创建具有以下属性
的缺省线程： 进程范围 非分离 缺省栈和缺省栈大小 零优先级
线程的ID号，创建
线程创建 int pthread_create (pthread_t * thread, __const pthread_attr_t * attr, void *(*__start_routine) (void *), void *arg); thread：指向线程标识符的指针，被创建的线程的标识符将由操作系统 写入到此结构中； attr：设置线程属性，如果为空指针（NULL），则表示采用缺省类型； start_routine：线程运行函数的起始地址； arg：指向运行函数参数的指针。
当创建线程成功时，函数返回0，若不为0 则说明创建线程失败，常见的 错误返回代码为EAGAIN 和EINVAL。前者表示系统限制创建新的线程， 例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创 建线程成功后，新创建的线程运行start_routine函数，其输入参数由arg 确定，原来的线程则继续运行下一行代码。
线程属性
初始化属性
int pthread_attr_init(pthread_attr_t *tattr);
线程属性
销毁属性 int pthread_attr_destroy(pthread_attr_t *tattr); 设置分离状态
int pthread_attr_setdetachstate(pthread_attr_t *tattr,int
线程属性
设置调度策略
int pthread_attr_setschedpolicy(pthread_attr_t *tattr, int policy); POSIX 标准指定的Policy：
Linux下c语言多线程编程
Linux下c语⾔多线程编程引⾔ 线程（thread）技术早在60年代就被提出，但真正应⽤多线程到中去，是在80年代中期，solaris是这⽅⾯的佼佼者。
传统的Unix也⽀持线程的概念，但是在⼀个进程（process）中只允许有⼀个线程，这样多线程就意味着多进程。
现在，多 为什么有了进程的概念后，还要再引⼊线程呢？使⽤多线程到底有哪些好处？什么的系统应该选⽤多线程？我们⾸先必须回答这些问题。
使⽤多线程的理由之⼀是和进程相⽐，它是⼀种⾮常"节俭"的多任务操作⽅式。
我们知道，在Linux系统下，启动⼀个新的进程必须分配给它独⽴的地址空间，建⽴众多的数据表来维护它的代码段、堆栈段和数据段，这是⼀种"昂贵"的多任务⼯作⽅式。
⽽运⾏于⼀个进程中的多个线程，它们彼此之间使⽤相同的地址空间，共享⼤部分数据，启动⼀个线程所花费的空间远远⼩于启动⼀个进程所花费的空间，⽽且，线程间彼此切换所需的时间也远远⼩于进程间切换所需要的时间。
使⽤多线程的理由之⼆是线程间⽅便的机制。
对不同进程来说，它们具有独⽴的数据空间，要进⾏数据的传递只能通过通信的⽅式进⾏，这种⽅式不仅费时，⽽且很不⽅便。
线程则不然，由于同⼀进程下的线程之间共享数据空间，所以⼀个线程的数据可以直接为其它线程所⽤，这不仅快捷，⽽且⽅便。
当然，数据的共享也带来其他⼀些问题，有的变量不能同时被两个线程所修改，有的⼦程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地⽅。
除了以上所说的优点外，不和进程⽐较，多线程程序作为⼀种多任务、并发的⼯作⽅式，当然有以下的优点： 1) 提⾼应⽤程序响应。
这对图形界⾯的程序尤其有意义，当⼀个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应、、菜单的操作，⽽使⽤多线程技术，将耗时长的操作（time consuming）置于⼀个新的线程，可以避免这种尴尬的情况。
Linux程序设计课程设计
Linux程序设计课程设计一、课程设计概述本次课程设计旨在通过Linux编程实践，深入了解Linux系统结构、进程管理、内存管理、文件系统等基础知识，并提升学生在Linux编程能力和开发经验，掌握常用应用程序的编写方法，培养独立分析问题和解决问题的能力。
二、设计内容及目的1. Shell脚本编写目的了解Shell脚本的基础语法和使用，能够编写简单的Shell脚本，实现基本的系统管理。
内容1.Shell脚本基础语法2.Shell变量、数组、流程控制语句3.Shell脚本常用实例4.Shell脚本与Linux系统管理结合2. Linux系统调用编程目的掌握Linux系统调用的基本原理，了解进程管理、内存管理、文件系统等方面的基础知识，并能够编写常用的应用程序。
内容1.Linux系统调用基础知识2.进程和线程管理的编程实现3.内存管理的编程实现4.文件系统的编程实现3. Linux网络编程目的熟悉Linux系统下网络编程的基本原理和常用方法，能够编写网络应用程序，进行网络通信。
内容1.网络编程基础知识2.套接字和协议的使用3.网络应用程序的开发4.网络安全相关知识三、课程设计流程1.确定课程设计题目和要求，分组进行；2.提供Linux开发环境和相关的学习资料；3.学生自主学习相关知识，按照要求进行课程设计；4.指导教师进行课程设计及进度的跟踪和管理；5.学生进行课程设计展示和提交报告。
四、课程设计考核方式1.课程设计实验报告：50% 要求报告包含课程设计题目、设计思路、核心代码、系统测试和总结等2.课程设计展示答辩：50% 要求学生对自己的设计思路和核心代码进行展示和讲解，并在指导教师面前进行答辩。
五、课程设计心得通过本次课程设计的学习，我对Linux系统有了更深入的了解，对Linux编程技巧也有了更多的认识。
在编写Shell脚本和系统调用编程方面，我学会了很多实用的方法，也深入了解了Linux系统的运行机制和调试技巧。
多核程序设计Linux多线程编程PPT教学课件
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex); 初始化mutex
2020/12/10
8
POSIX 线程库对mutex提供了以下函数进行操作：
int pthread_mutex_init(pthread_mutex_t *mutex, const
pthread_mutexattr_t *mutexattr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
2020/12/10
9
线程使用mutex的简单代码如下：
pthread_mutex_t mylock; mylock= PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&mylock); /*………….*/ pthread_mutex_unlock(&mylock);
4
2020/12/10
5
2020/12/10
6
线程互斥和同步——Mutex
原子性。对mutex的加锁和解锁操作是原子的，一个 线程进行 mutex 操作的过程中，其他线程不能对同 一个 mutex 进行其他操作。
单一性。拥有mutex的线程除非释放mutex，否则其 他线程不能拥有此mutex。
void pthread_exit (void* retval);
• 除了pthread_exit() 函数，可以让当前调用pthread_exit() 的 线程显示地退出外，线程也可以使用 pthread_cancel() 函数 终止其他线程的执行。
Linux实验五 Linux进程管理
实验五Linux进程管理一、实验目的1．掌握Linux进程管理。
2．学习并掌握进程查看命令、进程终止命令。
3．使用at和cron服务实现Linux进程调度。
二、实验环境安装了Red Hat Linux9.0系统的计算机一台三、实验过程（实验步骤、记录、数据、分析、结果）（一）进程查看、终止、挂起及暂停等操作1、使用ps命令查看和控制进程1）显示本用户进程#ps分析：显示进程：shell和ps2）显示所有用户的进程#ps –au分析：显示共有8个进程3）在后台运行cat命令#cat&分析：PID为27244）查看进程cat#ps aux |grep cat5）杀死进程cat#kill -9 cat6）再次查看进程cat，看看是否被杀死。
分析：结果显示已经杀死cat2、使用top命令查看和控制进程1）用top命令动态显示当前的进程。
分析：显示当前的进程2）只显示某一用户的进程（u）分析：pm进程的PID为123）杀死指定进程号的进程（k）3、挂起和恢复进程1）执行命令cat分析：重新执行cat命令，PID号变成28852）按【ctrl+z】挂起进程3）输入jobs命令，查看作业分析：按【ctrl+z】挂起进程后，用jobs命令查看作业，cat被挂起。
4）输入bg，把cat切换到后台执行5）输入fg，把cat切换到前台执行6）按【ctrl+c】结束进程（二）通过at命令实现计划任务1、5分钟后执行/bin/date#at now+5minutesat>/bin/dateat><EOT>(提示：输入【ctrl+d】job任务号at 年-月-日小时：分钟如何查看结果？2、查找系统中任何以c为后缀名的文档，将结果保存到$HOME/findc文件中，指定时间为2016年12月01日早上8点#at 8am 12/01/16at>find / -name ‘*.c’ >$HOME/findcat><EOT>job任务号at 年-月-日小时：分钟如何查看结果？分析：指定时间必须要在当前时间之后，将12月1日16点改为12月28日16点3、2题的命令写到$HOME/findjob中，使用at命令执行，并将结果保存到$HOME/findfc文件中，指定时间为当前时间后5分钟#vi $HOME/findjob内容如下：find / -name ‘*.c’ >$HOME/findfc存盘退出#at –f $HOME/findjob now+5minutes4、at命令实现在30天后统计/etc/inittab文件的行数，将统计结果发送至$HOME/initline文件中#at now+3daysat>wc –l /etc/inittab>>$HOME/initlineat><EOT>5、列出现有的所有at任务，并记下相关信息分析：5分钟已过去，第一个at计划已经执行，上面3个计划等待执行。
linux课程设计报告
《Linux操作系统》课程设计报告题目：Linux对进程和线程的治理机制研究所在院系：软件学院完成学生： zhangsan 运算机科学与技术指导教师： lisi 完成日期： 2012年 6 月 6 日目录1. 课程设计题目概述 (1)2. 研究内容与目的 (4)3. 研究报告 (5)4. 总结 (17)1. 课程设计题目概述Linux是一个多用户多任务的操作系统。
多用户是指多个用户能够在同一时刻利用运算机系统；多任务是指Linux能够同时执行几个任务，它能够在还未执行完一个任务时又执行另一项任务。
操作系统治理多个用户的请求和多个任务。
大多数系统都只有一个CPU和一个主存，但一个系统可能有多个二级存储磁盘和多个输入/输出设备。
操作系统治理这些资源并在多个用户间共享资源，当您提出一个请求时，给您造成一种假象，仿佛系统只被您独自占用。
而事实上操作系统监控着一个等待执行的任务队列，这些任务包括用户作业、操作系统任务、邮件和打印作业等。
操作系统依照每一个任务的优先级为每一个任务分派适合的时刻片，每一个时刻片大约都有零点几秒，尽管看起来很短，但事实上已经足够运算机完成成千上万的指令集。
每一个任务都会被系统运行一段时刻，然后挂起，系统转而处置其他任务；过一段时刻以后再回来处置那个任务，直到某个任务完成，从任务队列中去除。
Linux系统上所有运行的东西都能够称之为一个进程。
每一个用户任务、每一个系统治理守护进程，都能够称之为进程。
Linux用分时治理方式使所有的任务一起分享系统资源。
咱们讨论进程的时候，可不能去关切这些进程究竟是如何分派的，或是内核如何治理分派时刻片的，咱们所关切的是如何去操纵这些进程，让它们能够专门好地为用户效劳。
在Linux中，每一个进程在创建时都会被分派一个数据结构，称为进程操纵块（Process Control Block，简称PCB）。
PCB中包括了很多重要的信息，供系统调度和进程本身执行利用，其中最重要的莫过于进程ID（process ID）了，进程ID也被称作进程标识符，是一个非负的整数，在Linux操作系统中唯一地标志一个进程，在咱们最常利用的I386架构（即PC利用的架构）上，一个非负的整数的转变范围是0-32767，这也是咱们所有可能取到的进程ID。
linux学习步骤
第一阶段Linux系统管理与编程基础1. 嵌入式系统概述2. Linux介绍2. Linux定制安装3. Linux命令详解1. Linux系统管理2. Shell 编程3. Shell 编程综合实例-qcd1. GCC程序编译2. GDB程序调试3. Makefile 工程管理第二阶段应用程序设计1. Linux文件编程（系统调用）2. Linux文件编程（库函数）3. Linux时间编程1. Linux 进程基础2. Linux多进程程序设计1. 进程间通讯概述2. 管道通讯3. 信号通讯4. 共享内存通讯1. 消息队列通讯2. 信号灯1. Linux线程基础2. Linux线程创建3. Linux线程等待4. Linux线程清除1. IP协议分析2. TCP协议分析3. UDP协议分析4. TCP通讯程序设计5. UDP通讯程序设计6. 并发服务器模型7. 多路复用第三阶段ARM程序设计1. ARM处理器概述2. ARM处理器工作模式3. ARM系统寄存器4. ARM寻址方式5. ARM 汇编指令集6. ARM环境C语言编程7. ADS集成开发环境1. LED程序设计2. ARM中断与异常3. S3c2440 GPIO4. 按键程序设计5. 串口程序设计第四阶段Linux内核开发1. Linux内核简介2. Linux内核源代码结构3. Linux内核配置与裁剪4. Linux内核模块开发5. Linux内核启动流程1. 嵌入式Linux产品开发流程2. 交叉工具链3. Bootloader介绍4. U-Boot介绍5. U-Boot命令6. U-Boot工作原理7. U-Boot移植1. 嵌入式Linux内核制作2. 根文件系统制作3. 嵌入式文件系统介绍1. Linux内存管理2. Linux进程地址空间3. Linux内核地址空间4. Linux内核链表5. Linux内核定时器1. Linux进程控制2. Linux进程调度3. Linux系统调用4. Proc文件系统5. Linux内核异常分析第五阶段Linux驱动程序设计1．Linux驱动简介2．字符设备驱动程序设计3．驱动调试技术4. 并发与竞态1．Ioctl型驱动2．内核等待队列3. 阻塞型驱动程序设计4．Poll 设备操作1．Mmap设备操作2. 硬件访问3. 混杂设备驱动4. LED驱动程序设计1. Linux总线、设备、驱动模型2. Linux platform驱动3. 中断处理4. 按键驱动程序1．Linux网络体系架构2. Linux网卡驱动程序设计3. Dm9000网卡驱动程序分析4. 触摸屏驱动程序设计1. PCI驱动程序设计2. 串口驱动程序设计深入专题—SUB系统开发1. USB简介2. USB系统架构3. USB设备逻辑结构4. USB描述符5. USB传输6. USB枚举1. Linux USB系统架构2. Mass Storage3. USB HID4. RNDIS5. CDC/ACM1. USB驱动程序模型2. Linux USB描述符3. URB4. USB鼠标驱动程序详解深入专题—H。
多进程程序设计课程设计
多进程程序设计课程设计一、教学目标本课程的目标是让学生掌握多进程程序设计的基本概念、原理和方法，培养学生分析和解决多进程问题的能力。
具体目标如下：1.知识目标：–了解多进程程序设计的基本概念和原理。
–掌握多进程的创建、调度和管理方法。
–熟悉多进程程序设计的相关API和编程技巧。
2.技能目标：–能够运用多进程程序设计原理分析和解决实际问题。
–能够使用相关编程工具和调试技巧进行多进程程序设计。
–具备一定的代码阅读和编写能力，能够阅读和理解多进程程序代码。
3.情感态度价值观目标：–培养学生对计算机科学的兴趣和热情，提高学生对多进程程序设计的认识。
–培养学生团队协作精神和自主学习能力，鼓励学生积极参与讨论和交流。
–培养学生良好的编程习惯和职业道德，提高学生的编程素养。
二、教学内容根据课程目标，本课程的教学内容主要包括以下几个方面：1.多进程程序设计的基本概念和原理：进程的定义、进程的状态、进程控制块、进程的创建和终止等。
2.多进程的创建和管理：fork()函数、exec()函数、wt()和wtpid()函数、进程调度算法等。
3.多进程间的通信：管道、信号、共享内存等通信机制。
4.多进程程序设计的实例分析和实践：通过分析实际的多进程程序设计案例，让学生掌握编程技巧和方法。
5.相关API和编程技巧的讲解和实践：讲解Linux和Windows平台下的多进程编程API，引导学生进行实际编程练习。
三、教学方法本课程采用多种教学方法，以激发学生的学习兴趣和主动性：1.讲授法：教师讲解基本概念、原理和方法，引导学生理解多进程程序设计的核心内容。
2.案例分析法：分析实际的多进程程序设计案例，让学生掌握编程技巧和方法。
3.实验法：安排实验课程，让学生亲自动手编写代码，培养学生的实际编程能力。
4.讨论法：学生进行小组讨论，鼓励学生提出问题、分享心得，提高学生的团队协作能力和自主学习能力。
四、教学资源为了支持教学内容和教学方法的实施，本课程准备以下教学资源：1.教材：选择一本合适的教材，如《多进程程序设计教程》等。
LinuxBASH多进程并行处理的方法实现
LinuxBASH多进程并⾏处理的⽅法实现复制代码代码如下:#!/bin/bashSEND_THREAD_NUM=13tmp_fifofile="/tmp/$$.fifo" # 脚本运⾏的当前进程ID号作为⽂件名mkfifo “$tmp_fifofile" # 新建⼀个随机fifo管道⽂件exec 6<>"$tmp_fifofile" # 定义⽂件描述符6指向这个fifo管道⽂件rm $tmp_fifofilefor ((i=0;i<$SEND_THREAD_NUM;i++));doecho # for循环往 fifo管道⽂件中写⼊13个空⾏done >&6for i in `seq 100`;do # 100 次 for 循环开始read -u6 # 从⽂件描述符6中读取⾏（实际指向fifo管道){echo $i # 打印 isleep 3 # 暂停3秒echo >&6 # 再次往fifo管道⽂件中写⼊⼀个空⾏。
} &# {} 这部分语句被放⼊后台作为⼀个⼦进程执⾏，所以不必每次等待3秒后执⾏#下⼀个,这部分的echo $i⼏乎是同时完成的，当fifo中13个空⾏读完后 for循环# 继续等待 read 中读取fifo数据，当后台的13个⼦进程等待3秒后，按次序# 排队往fifo输⼊空⾏，这样fifo中⼜有了数据，for语句继续执⾏pid=$! #打印最后⼀个进⼊后台的⼦进程idecho $piddonewaitexec 6>&- #删除⽂件描述符6exit 0。
并发程序设计1：多进程并发
并发程序设计1：多进程并发在并发程序设计中，主要有三种并发⽅式：多进程并发，基于IO复⽤并发，多线程并发。
本节主要介绍多进程并发。
以多客户端ehco程序为例。
1. 进程进程是具有独⽴功能的程序关于某个数据集合的⼀次运⾏活动，是OS为正在运⾏的程序建⽴的管理实体，是系统资源管理与分配的基本单位。
⼀个进程有五部分：操作系统管理该进程的数据结构(PCB)，内存代码，内存数据，程序状态字PSW，通⽤寄存器信息。
⼀个进程在OS中有四个基本状态。
如图1.1所⽰。
图1.1 进程四态挂起：挂起是OS收回进程的所有资源，将其移出内存。
创建进程时，实际上OS为其建⽴⼀个进程控制块，⽤于保存该进程的信息。
多个进程同时运⾏时，其在内存中的状态如图1.2所⽰。
图1.2 多进程的内核状态2. 多进程并发进程是程序运⾏的基本单位，对于多内核的计算机，多个进程可以在多内核上同时运⾏，提⾼程序的并发性。
如对于C/S类型的模型，客户端每发起⼀次通信，服务器开辟⼀个进程于其连接。
这样实现服务器同时服务多个客户端。
以经典的回声服务器，客户端为例，讲解多进程并发(注：Windows系统不⽀持，相关代码均以Linux系统为例)。
Linux系统的每个进程都有⼀个标志号，称为进程ID，其值⼤于2(1要分配给系统启动后的⾸个进程，⽤于协助操作系统)。
在Linux系统中，创建⼀个进程采⽤fork函数#include <unistd.h>pid_t fork(void); //pid_t为返回的ID号调⽤fork函数之后，⼦进程创建，⼦进程会复制⽗进程的所有信息，然后从fork调⽤之后开始执⾏。
那么怎么让⽗⼦进程执⾏不同的程序路径呢？这是通过主程序判断实现的，⽗进程调⽤fork函数，返回的是⼦进程的ID；⽽⼦进程的fork函数返回0，通过此返回值区别⽗⼦进程，从⽽控制fork函数之后的执⾏流。
2.1 僵⼫进程 ⽗进程fork⼦进程后，两个进程按各⾃的程序执⾏。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告实验名称：Linux 多进程程序设计一、实验目的熟悉Linux下多进程编程的方法，掌握Linux下fork、exec、wait、waitpid 等进程相关的系统调用使用方法。
二、实验内容在父进程中创建两个子进程，其中一个子进程运行“ls -l”指令，另一个子进程在暂停5s之后退出。
父进程先用阻塞方式等待第一个子进程的结束，然后用非阻塞方式等待第二个子进程的退出，待收集到第二个子进程结束的信息，父进程就返回。
三、实验内容1、程序说明、流程图等父进程首先创建一个子进程A，采用组赛模式等待进程A结束，然后创建进程B，采用非阻塞模式等待B 进程结束，然后父进程结束A进程运行 ps -efB进程等待5S 自动结束父进程会铺货进程A，B的结束，然后给予相应的提示。
2、程序代码#include <sys/types.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>#include <sys/wait.h>int main(void ){pid_t pa,pb,pr;pa=fork();if(pa<0){perror("fork a error!"); }else if(pa==0){sleep(1);printf("process A is running.......\n");if(execlp("ps","ps","-ef",NULL)<0){ perror("execlp a error!");}exit(0);}else{printf("this is parent process!\n");printf("parent process is wating for children !\n");printf("wating ......wating.......\n");pr=wait(NULL);if(pr==pa){printf("parent catched the child A!\n");}printf("creat process B!\n");pb=fork();if(pb<0){printf("error fork B\n");}else if(pb==0){printf("B process is running( 5 S )!\n");sleep(5);printf("B process end!\n");exit(0);}else{do{pr=waitpid(pb,NULL,WNOHANG);if(pr==0)/*B not end*/{printf("father is wating for child B!\n");sleep(1);}}while(pr==0);/*wait for process B*/if(pr==pb)printf("child B very well!\n");elseprintf("my child B lost!");}}}3、运行测试输出的结果this is parent process!parent process is wating for children !wating ......wating.......process A is running.......UID PID PPID C STIME TTY TIME CMDroot 1 0 0 02:57 ? 00:00:01 /sbin/init root 2 0 0 02:57 ? 00:00:00 [kthreadd] root 3 2 0 02:57 ? 00:00:00 [ksoftirqd/0] root 5 2 0 02:57 ? 00:00:00 [kworker/u:0]root 7 2 0 02:57 ? 00:00:00 [cpuset]root 8 2 0 02:57 ? 00:00:00 [khelper]root 9 2 0 02:57 ? 00:00:00 [netns]root 10 2 0 02:57 ? 00:00:00 [sync_supers] root 11 2 0 02:57 ? 00:00:00 [bdi-default] root 12 2 0 02:57 ? 00:00:00 [kintegrityd] root 13 2 0 02:57 ? 00:00:00 [kblockd]root 14 2 0 02:57 ? 00:00:00 [kacpid]root 15 2 0 02:57 ? 00:00:00 [kacpi_notify] root 16 2 0 02:57 ? 00:00:00 [kacpi_hotplug] root 17 2 0 02:57 ? 00:00:00 [ata_sff]root 18 2 0 02:57 ? 00:00:00 [khubd]root 19 2 0 02:57 ? 00:00:00 [md]root 22 2 0 02:57 ? 00:00:00 [khungtaskd]root 23 2 0 02:57 ? 00:00:00 [kswapd0]root 24 2 0 02:57 ? 00:00:00 [ksmd]root 25 2 0 02:57 ? 00:00:00 [fsnotify_mark] root 26 2 0 02:57 ? 00:00:00 [aio]root 27 2 0 02:57 ? 00:00:00 [ecryptfs-kthrea] root 28 2 0 02:57 ? 00:00:00 [crypto]root 32 2 0 02:57 ? 00:00:00 [kthrotld]root 34 2 0 02:57 ? 00:00:00 [scsi_eh_0]root 35 2 0 02:57 ? 00:00:01 [scsi_eh_1]root 36 2 0 02:57 ? 00:00:00 [kworker/u:3] root 39 2 0 02:57 ? 00:00:00 [kmpathd]root 40 2 0 02:57 ? 00:00:00 [kmpath_handlerd] root 41 2 0 02:57 ? 00:00:00 [kondemand]root 42 2 0 02:57 ? 00:00:00 [kconservative] root 160 2 0 02:57 ? 00:00:00 [scsi_eh_2]root 177 2 0 02:57 ? 00:00:00 [ext4-dio-unwrit]root 224 1 0 02:57 ? 00:00:00 upstart-udev-bridge --daemon root 235 1 0 02:57 ? 00:00:00 udevd --daemonsyslog 329 1 0 02:57 ? 00:00:00 rsyslogd -c4102 334 1 0 02:57 ? 00:00:00 dbus-daemon --system --fork -- avahi 361 1 0 02:57 ? 00:00:00 avahi-daemon: running [hao-Vir avahi 362 361 0 02:57 ? 00:00:00 avahi-daemon: chroot helper root 375 1 0 02:57 ? 00:00:00 NetworkManagerroot 383 1 0 02:57 ? 00:00:00 /usr/sbin/modem-managerroot 392 1 0 02:57 ? 00:00:00 /usr/lib/policykit-1/polkitd root 437 1 0 02:57 ? 00:00:00 /sbin/wpa_supplicant -u -s root 445 2 0 02:57 ? 00:00:00 [kpsmoused]root 506 2 0 02:57 ? 00:00:00 [iprt]root 526 1 0 02:57 ? 00:00:00 upstart-socket-bridge --daemonroot 606 1 0 02:57 tty4 00:00:00 /sbin/getty -8 38400 tty4 root 614 1 0 02:57 tty5 00:00:00 /sbin/getty -8 38400 tty5 root 626 1 0 02:57 tty2 00:00:00 /sbin/getty -8 38400 tty2 root 633 1 0 02:57 tty3 00:00:00 /sbin/getty -8 38400 tty3 root 636 1 0 02:57 tty6 00:00:00 /sbin/getty -8 38400 tty6 daemon 643 1 0 02:57 ? 00:00:00 atdroot 644 1 0 02:57 ? 00:00:00 acpid -c /etc/acpi/events -s /root 645 1 0 02:57 ? 00:00:00 cronroot 664 2 0 02:57 ? 00:00:00 [flush-8:0]root 746 1 0 02:57 ? 00:00:02 /usr/sbin/VBoxServiceroot 905 1 0 02:57 ? 00:00:00 gdm-binaryroot 908 1 0 02:57 ? 00:00:00 /usr/sbin/cupsd -Froot 910 1 0 02:57 tty1 00:00:00 /sbin/getty -8 38400 tty1root 914 1 0 02:57 ? 00:00:00 /usr/sbin/console-kit-daemon -root 980 905 0 02:57 ? 00:00:00 /usr/lib/gdm/gdm-simple-slave root 985 980 2 02:57 tty7 00:01:28 /usr/bin/X :0 -nr -verbose -au root 1000 980 0 02:57 ? 00:00:00 /usr/lib/gdm/gdm-session-workehao 1009 1000 0 02:57 ? 00:00:00 gnome-session --session=ubuntuhao 1052 1 0 02:57 ? 00:00:00 /usr/bin/VBoxClient --clipboarhao 1064 1 0 02:57 ? 00:00:00 /usr/bin/VBoxClient --display hao 1070 1 0 02:57 ? 00:00:00 /usr/bin/VBoxClient --seamlesshao 1076 1 0 02:57 ? 00:00:30 /usr/bin/VBoxClient --draganddhao 1079 1009 0 02:57 ? 00:00:00 /usr/bin/ssh-agent /usr/bin/dbhao 1082 1 0 02:57 ? 00:00:00 /usr/bin/dbus-launch --exit-wihao 1083 1 0 02:57 ? 00:00:01 //bin/dbus-daemon --fork --pri hao 1088 1 0 02:57 ? 00:00:00 /usr/lib/libgconf2-4/gconfd-2 hao 1101 1 0 02:57 ? 00:00:00 /usr/bin/gnome-keyring-daemon hao 1106 1 0 02:57 ? 00:00:04 /usr/lib/gnome-settings-daemonhao 1109 1 0 02:57 ? 00:00:00 /usr/lib/gvfs/gvfsdhao 1114 1009 0 02:57 ? 00:00:05 metacityhao 1116 1 0 02:57 ? 00:00:00 /usr/lib/gvfs//gvfs-fuse-daemohao 1120 1 0 02:57 ? 00:00:04 /usr/bin/pulseaudio --start -- rtkit 1122 1 0 02:57 ? 00:00:00 /usr/lib/rtkit/rtkit-daemonhao 1127 1009 0 02:57 ? 00:00:10 nautilushao 1128 1009 0 02:57 ? 00:00:00 /usr/lib/evolution/2.32/evoluthao 1131 1009 0 02:57 ? 00:00:04 gnome-panelhao 1135 1009 0 02:57 ? 00:00:00 zeitgeist-datahubhao 1137 1120 0 02:57 ? 00:00:00 /usr/lib/pulseaudio/pulse/gconhao 1138 1009 0 02:57 ? 00:00:00 nm-applet --sm-disablehao 1140 1009 0 02:57 ? 00:00:00 gnome-power-managerhao 1142 1009 0 02:57 ? 00:00:00 /usr/lib/policykit-1-gnome/polhao 1143 1009 0 02:57 ? 00:00:00 bluetooth-applethao 1152 1 0 02:57 ? 00:00:00 /usr/lib/gvfs/gvfs-gdu-volume-root 1156 1 0 02:57 ? 00:00:00 /usr/lib/udisks/udisks-daemon root 1158 1156 0 02:57 ? 00:00:01 udisks-daemon: polling /dev/sr hao 1160 1 0 02:57 ? 00:00:01 /usr/bin/python /usr/bin/zeitghao 1163 1 0 02:57 ? 00:00:00 /usr/lib/gvfs/gvfs-afc-volume-hao 1167 1 0 02:57 ? 00:00:00 /usr/lib/gvfs/gvfs-gphoto2-volhao 1171 1160 0 02:57 ? 00:00:00 /bin/cathao 1176 1160 0 02:57 ? 00:00:00 [zeitgeist-datah] <defunct> root 1195 1 0 02:57 ? 00:00:00 /usr/lib/upower/upowerdhao 1263 1 0 02:57 ? 00:00:00 /usr/lib/gvfs/gvfsd-trash --sphao 1265 1 0 02:57 ? 00:00:00 gnome-screensaverhao 1272 1 0 02:57 ? 00:00:02 /usr/lib/notify-osd/notify-osdhao 1290 1 0 02:57 ? 00:00:00 /usr/lib/bonobo-activation/bonhao 1303 1 0 02:57 ? 00:00:03 /usr/lib/gnome-panel/wnck-applhao 1305 1 0 02:57 ? 00:00:00 /usr/lib/gnome-applets/trashaphao 1311 1 0 02:57 ? 00:00:00 /usr/lib/gnome-panel/notificathao 1312 1 0 02:57 ? 00:00:01 /usr/lib/indicator-applet/indihao 1327 1009 0 02:57 ? 00:00:00 /usr/lib/gnome-disk-utility/gdhao 1330 1 0 02:57 ? 00:00:00 /usr/lib/gvfs/gvfsd-burn --spahao 1339 1 0 02:57 ? 00:00:00 /usr/lib/gvfs/gvfsd-metadata hao 1343 1 0 02:57 ? 00:00:00 /usr/lib/d-conf/dconf-service hao 1347 1 0 02:57 ? 00:00:00 /usr/lib/indicator-messages/inhao 1349 1 0 02:57 ? 00:00:00 /usr/lib/indicator-sound/indichao 1351 1 0 02:57 ? 00:00:00 /usr/lib/indicator-applicationhao 1353 1 0 02:57 ? 00:00:00 /usr/lib/indicator-session/indhao 1356 1 0 02:57 ? 00:00:00 /usr/lib/indicator-datetime/inhao 1357 1 0 02:57 ? 00:00:00 /usr/lib/indicator-me/indicatohao 1397 1 0 02:57 ? 00:00:00 /usr/lib/geoclue/geoclue-mastehao 1399 1009 0 02:57 ? 00:00:00 /usr/bin/python /usr/share/syshao 1404 1 0 02:58 ? 00:00:02 /usr/lib/bamf/bamfdaemon hao 1409 1009 0 02:58 ? 00:00:00 update-notifierroot 1864 2 0 03:32 ? 00:00:00 [kworker/0:0]root 1871 2 0 03:37 ? 00:00:00 [kworker/0:1]root 1918 2 0 03:42 ? 00:00:00 [kworker/0:2]root 1954 235 0 03:45 ? 00:00:00 udevd --daemonroot 1955 235 0 03:45 ? 00:00:00 udevd --daemonroot 1983 2 0 03:45 ? 00:00:00 [kworker/0:3]hao 2010 1 1 03:46 ? 00:00:03 gedit /home/hao/Desktop/test.chao 2015 1 1 03:47 ? 00:00:01 gnome-terminalhao 2019 2015 0 03:47 ? 00:00:00 gnome-pty-helperhao 2020 2015 0 03:47 pts/0 00:00:00 bashhao 2085 2020 0 03:49 pts/0 00:00:00 ./testhao 2086 2085 3 03:49 pts/0 00:00:00 ps -efparent catched the child A!creat process B!father is wating for child B!B process is running( 5 S )!father is wating for child B!father is wating for child B!father is wating for child B!father is wating for child B!B process end!child B very well!hao@hao-VirtualBox:~/Desktop$。