进程线程笔记
DAY 1
进程的基本概念：
1．进程与程序的区别：
程序：存储在磁盘上可执行指令的集合，是一个文件。
例如：a.out文件就是一个程序。
进程：程序一次执行的过程，伴随着资源的分配和释放。
区别：
<1>进程是动态的,运行在内存中，并伴随着资源的分配与释放。
<2>程序是静态的，一般存在在磁盘上，没有执行的概念。
2.进程的标示
就绪态：进程所有需要的条件已经准备完成,等待CPU的调度。
运行态(R-->running)：进程占用CPU，并在CPU上运行。
可中断等待态(S)：进程正在休眠，等待某个资源来唤醒它。也可以被其他信号中断唤醒。
不可中断等待态(D)：进程正在休眠，等待某个资源来唤醒它。不能
被其他信号中断唤醒。
停止态（T）:进程暂停接受某种处理。例如：gdb调试断点信息处理。僵尸态（Z）：进程以及结束但是还没有释放进程资源。例如：PID，PPID等未释放。
+ : 表示该进程在前台运行。例如：S+ ,R+等,没有+表示在后台运行。各个状态之间的转换如下图:
时间片：CPU分配给一个进程所运行的时候。实现消耗完成后，进程处于等待态。
3.进程相关命令详解
（1）常用：pstree -p.
<2>ps(process status) 查看当前系统进程的工具
a.给当前进程截取一个快照,来查看我们的PID号
ps -ef | grep “进程名/进程ID”
b.查看进程第一行的信息。
ps -ef | head -1
c.查看当前进程的状态
ps aux | grep “进程名/进程ID”
<3>kill 给指定的PID进程发送信号
使用方法：
kill -信号的宏名 PID 或者 kill -信号的编号 PID号
常用宏：
宏名编号功能
SIGKILL 9 杀死进程。
SIGCONT 18 让信号继续运行。
SIGSTOP 19 让信号停止。
SIGCHLD 17 子进程结束的时候，给父进程发送该
信号。
<4>bg(backgroud) 将一个挂起的进程在后台的运行。
使用方法：bg job号把挂起的进程放到后台运行。
<5>fg(foreground) 将后台的进程到前台运行。
./a.out 默认是在前台运行我们的程序。我们可以在启动的时候让我们的程序在后台运行。
./a.out & 让程序在后台运行。这里的&符合表示把我们的程序放到
后台来运行。
fg的使用方法： fg job号把后台的进程放到前台运行。
常用概念了解：
（1）ctrl + z 给当前前台执行的命令放到后台，并且将进程暂停挂起。
（2）jobs 看出当前后台运行的程序，并显示其job号
4. 创建子进程函数
<1>创建进程[pid_t 是int类型]
#include
pid_t fork(void)；
功能:在当前进程中，创建子进程
返回值：
成功给父进返回子进错的pid号
给子进错返回0，
失败返回-1，并且置errno,
注意：
<1>fork 是通过对当调用fork()的进程的复制来实现对新进程的创建
子进程：新创建的进程
父进程：调用fork()函数的进程。
<2>子进程创建的过程：拷贝父进程的堆，栈，rodata段，data段，bss段,
系统相关信息,代码段共享。
<3>fork之后父，子进程谁先执行是不确定，取决系统的调度算法
<4>fork之后，父子进程都是从fork下一条语句开始执行
<5>fork之后，父子进程拥有独立的4G虚拟地址空间。互相不影响
<6>fork之后，子进程会继承父进程的打开的文件描述符集合，共用相同的文件表项。
思考：我们如何根据pid来判断当前进程是父进程还是子进程呢？
pid > 0 表示此时是父进程的运行空间。
pid == 0 表示此时是子进程的运行空间
僵尸子进程：子进程结束的时候，父进程没有进行收尸操作(父进程还存在),
此时占用资源。
孤儿进程：父进程结束了，子进程会变成孤儿进程，会自动被init进程所收养。
5. vfork函数详解
<1>写时拷贝简介
详见《3.写时拷贝简介》
<2>vfork
#include
#include
pid_t vfork(void);
功能：创建子进程
参数：无
返回值：成功，对父进程而言。返回子进程的PID好。
对子进程而言。返回0.
错误，返回-1。
fork与vfork的区别：
<1>fork函数父子进程谁先运行不确定，由系统调度决定。
vfork函数子进程先运行，此时父进程会阻塞，子进程会一直运行在
父进程的地址空间，直到子进程调用exit结束后才会运行，如果这时子进程修改了某个变量，这将影响到父进程
的变量。
<2>fork 函数的正文段共享，其他段被子进程复制。
vfork函数的子进程直接共享父进程的虚拟地址空间。
六、exec函数簇
exec函数簇函数[详见4.exec函数簇详解.doc]
<1>功能简介
exec函数族提供了一种在进程中启动另一个程序执行的方法。
它可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段、和堆栈段。
在执行完之后，原调用进程的内容除了进程号外，其他全部都被替换了。
潜规则：向函数传递指针数组的时候，一般以NULL作为结束的标志。
1)l : list [给可执行文件，以列举的方式传递文件]
int execl(const char *path, const char *arg1, ...);
参数：
@path 包含可路径的可制作文件的名字（例如：/home/ubuntu/hello）@arg1 可执行程序的名字(hello)
@arg2 可执行程序的参数等等(可省略) ....
@参数最后一定要以NULL结尾。
返回值：成功返回0，失败返回-1
例如：执行ls命令execl("/bin/ls","ls","-l"，NULL)；
环境变量：操作系统提高的全局变量。
2)p : PATH [在PATH环境变量中搜索，在任何一个地方都可以找到PATH环
境变量中的内容]
int execlp(const char *path, const char *arg1, ...);
int execlp(可执行文件名，可执行文件名，参数1，参数2,..,NULL);
例如：“ls -l”
execlp("ls","ls","-l",NULL);
3)e :environment (环境变量) 可以给新运行的程序传递一个环境变量。
如果新程序需要环境变量，可以通过envp参数传递环境变量
如果不需要，传NULL
int execle(const char *path, const char *arg,..., char * const envp[]);
参数：
参数：
@path 包含可路径的可制作文件的名字（例如：/home/ubuntu/hello）@arg1 可执行程序的名字(hello)
arg2 ......
参数最后一定要以NULL结尾。
@可以给新运行的程序传递一个环境变量. 如果新程序需要环境变量，可以通过envp参数传递环境变量
如果不需要，传NULL
例如：
execle("/bin/ls","ls","-a",NULL,NULL)；
============================================================= ===========
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *file, char *const argv[],char *const envp[]);
v：vector : 向量组织成一个数组。
例如：
execl("/bin/ls","ls","-l",NULL);
execlp("ls","ls","-l",NULL);
execle("ls","ls","-l",NULL,NULL);
------------------------------------------------------------------
char *args[] = {"ls","-l",NULL};
execv("/bin/ls",args);
execvp("ls",args); //把路径添加到path环境变量中。
execve("ls",args,NULL);
七、常用退出函数简介
<1>return 结束一个函数的执行。（当前程序不一定结束。）
<2>void exit(int status)[库函数]
功能：结束一个进程。结束之前会刷新缓冲区。
参数：@status 进程状态的标志。0表示正常结束，其他表示异常结束。
<3>void _exitvoid exit(int status) [系统调用]
功能：结束一个进程。结束之前不会刷新缓冲区。
参数：@status 进程状态的标志。0表示正常结束，其他表示异常结束。
八、回收僵尸态子进程
<1>思考：为什么要回收僵尸态子进程？
答：僵尸态子进程已经结束，它占用大部分资源已经释放，但是仍然保留PID 资源。
如果僵尸态子进程过多，会导致PID资源耗尽，创建子进程失败。
<2>常用函数
pid_t wait(int *status)
功能：回收僵尸态子进程，如果没有僵尸态的子进程则阻塞，如果没有子进程会立即返回
参数:
@status 是一个整型指针，指向的对象用来保存子进程退出时的状态
a. status若是为NULL ，表示忽略子进程退出时的状态。
b. status若是不为NULL ，表示保存子进程退出时的状态。
返回值:
成功返回僵尸态子进程的PID，失败返回-1(没有子进程)
子进程的结束状态可由Linux中一些特定的宏来测定。
【注：这里的status为int类型，是指针中所指向的内容】
WIFEXITED(status) 返回值位非0值表示正常退出。0表示异常退出。
WEXITSTATUS(status) 取得子进程exit()返回的结束代码，一般会先用WIFEXITED来判断是否正常结束，然后才使用此宏。
=============================================== WIFSIGNALED(status) 如果子进程是因为信号而结束则，返回值为非0 。
否则，返回值为0。
WTERMSIG(status) 取得子进程因信号而中止的信号代码，一般会先用
WIFSIGNALED来判断后，然后才使用此宏
注意：
wait函数是以阻塞（暂停）方式等待子进程结束，等待当前父进程的任一子进程的退出！
如果是多个子进程，要实现对所有子进程的收尸操作，需要循环调用wait来实
现！
只能判断进程结束这种状态改变
============================================================ 思考：什么是阻塞，什么是非阻塞呢？
阻塞：得到调用的结果之前。一直等待。直到获得了结果再去做其他的事情。非阻塞：得到调用的结果之前。你可以做其它的事情。当获得了结果告诉我一声就可以了。
pid_t waitpid(pid_t pid, int *status, int options);
功能：按照指定的方式（是否阻塞）探测子进程状态的改变。R-Z,R->T,T->R 参数
@pid 子进程的pid号
-1 探测所有的子进程。
0 关心和父进程同组的子进程。
>0 等待指定pid的进程的状态改变
@status 获得子进程的退出状态值
@option 子进程的发探测方式
0 : 以阻塞的方式调用。
WNOHANG waitpid以非阻塞调用如果没有子进程状态发生改变，waitpid不阻塞，立即返回，此时返回值0
WUNTRACED 子进程状态的改变R->T
WCONTINUED 子进程状态的改变T->R
返回值：
失败返回-1，errono被置ECHILD。
(
当pid所指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid
就会出错返回，这时errno被设置为ECHILD；
)
成功。若是option选项设置为0，返回值返回为子进程的PID号。
若是option选项设置为WNOHANG。当waitpid发现没有已退出的子进程可收集，则返回0。
常用方法：
<1>与wait(&status);实现相同功能
waitpid(-1,&status,0); <===>wait(&status);
waitpid(-1,NULL,0);<=====>wait(NULL);
<2>以非阻塞方式等待进程号为pid的子进程
waitpid(pid,&satus,WNOHANG);
阻塞方式: 父进程产生子进程,一直等待子结束。在等待的过程中不做任何的事情。
wait(&status)或waitpid(-1,&status,0);等待子进程结束
轮询方式:父进程创建子进程, 父进程做自己的事情，然后每次查询一下。子进程是否结束，若是结束了。就回收子进程的资源。
DAY2
守护进程：
守护进程有三个最基本的特点：后台运行，独立于终端，完成一定的任务。
建守护进程的步骤
<1>创建子进程，父进程退出
<2>在子进程中创建的新会话[脱离控制终端]
setsid()函数的作用：创建一个新的会话，并且担任该会话组的组长。具体作用
包括：让一个进程摆脱原会话的控制，让进程摆脱原进程的控制，让进程摆脱原控制终端的控制。
chdir()
<3>改变进程的工作目录到"/"
<4>重设文件掩码umask(0)
<5>关掉不需要的文件描述符号[0,1,2]==>标准输入、标准输出、标准出错。
DAY 3
线程
线程就是我们轻量的进程。它是程序执行的最小单元。
1.线程的概念
线程：多个线程共享同一个进程的地址空间，参与系统的同意调度。
我们可这个说，一个程序至少有一个进程，一个进程至少有一个线程。既然多个线程共享进程的地址空间。那么这个线程肯定是在进程中创建的。
进程、程序、线程之间的关系如下图：
一个进程只有一个执行主线(线程)，就是main函数。这个我们称为主线程（main pthread）。主线程是进程的执行线程。
特点：主线程总是第一个运行的线程。对等线程的执行顺序不确定。
那么多个线程间哪些进程的资源是共享，哪些资源是独有的呢？
答: 共享资源：全局变量，进程中打开的文件描述符等，用户ID等。
私有资源：线程ID(tid) ，系统相关的数据[函数运行环境]，局部变量，私有栈
思考：进程和线程的异同点呢?
相同点：1.都参与系统的统一调度。
2.都有自己的ID值。（进程pid，线程tid）。
互斥锁
进程与线程的区别 进程的通信方式 线程的通信方式
进程与线程的区别进程的通信方式线 程的通信方式 进程与线程的区别进程的通信方式线程的通信方式2011-03-15 01：04 进程与线程的区别： 通俗的解释 一个系统运行着很多进程，可以比喻为一条马路上有很多马车 不同的进程可以理解为不同的马车 而同一辆马车可以有很多匹马来拉--这些马就是线程 假设道路的宽度恰好可以通过一辆马车 道路可以认为是临界资源 那么马车成为分配资源的最小单位(进程) 而同一个马车被很多匹马驱动(线程)--即最小的运行单位 每辆马车马匹数=1 所以马匹数=1的时候进程和线程没有严格界限，只存在一个概念上的区分度 马匹数1的时候才可以严格区分进程和线程 专业的解释： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执 行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序 的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行 的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在 应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可 以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程 的调度和管理以及资源分配。这就是进程和线程的重要区别。 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的 能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中 必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的 其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以 并发执行 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有 独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响， 而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线 程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程 的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者 《操作系统的设计与实现》。对就个问题说得比较清楚。 +++ 进程概念
实验一 进程与线程
实验：进程与线程 一、实验目的 通过函数调用掌握进程之间的通信。 体会线程的存在，了解线程与进程的关系。 二、实验环境 PC+Win7操作系统 三、实验方法和实验步骤 1．准备工作 打开VC++6.0环境。 2．在程序编辑区内输入程序，实现两个数互换。 3. 在VC环境下建立一个控制台应用程序P1。系统启动一个进程（因为支持线程，OS会在进程中主动创建一个主线程）来运行该程序。输出该进程的ID号、以及该进程下面主线程的ID号。多运行几次，观察结果。 四、实验结果
补充：在VC环境下建立一个控制台应用程序P1。系统启动一个进程（因为支持线程，OS会在进程中主动创建一个主线程）来运行该程序。 在进程中，我们自己再创建一个子线程（子线程1），该子线程做的事情很简单，就是让它不停地输出如下信息： 子线程1正在运行第1次，其进程的ID号=~, 子线程1的ID号=~ 子线程1正在运行第2次，其进程的ID号=~, 子线程1的ID号=~ 。。。。。。 。。。。。。 子线程1正在运行第20次，其进程的ID号=~, 子线程1的ID号=~ 只要启动了一个子线程，实际上系统中是主线程和子线程1在并发执行。 主线程的功能是输出这样形式的内容： 主线程正在运行第1次，其进程的ID号=~,主线程的ID号=~ 主线程正在运行第2次，其进程ID号=~, 主线程的ID号=~ 。。。。。。 。。。。。。 主线程正在运行第20次，其进程ID号=~, 主线程的ID号=~ 多运行几次，观察主线程和子线程并发调动的次序。每次调度都一样吗？为什么？进程ID、主线程ID和子线程ID每次都一样吗？ 体会操作系统中并发的异步性。 程序代码如下： #include
操作系统第二章进程和线程复习题
第二章练习题 一、单项选择题 1．某进程在运行过程中需要等待从磁盘上读入数据，此时该进程的状态将（ C ）。 A. 从就绪变为运行； B．从运行变为就绪； C．从运行变为阻塞； D．从阻塞变为就绪 2．进程控制块是描述进程状态和特性的数据结构，一个进程（ D ）。 A.可以有多个进程控制块； B.可以和其他进程共用一个进程控制块； C.可以没有进程控制块； D.只能有惟一的进程控制块。 3．临界区是指并发进程中访问共享变量的（D）段。 A、管理信息 B、信息存储 C、数 据 D、程序 4. 当__ B__时，进程从执行状态转变为就绪状态。 A. 进程被调度程序选中 B. 时间片到 C. 等待某一事件 D. 等待的事件发生 5. 信箱通信是一种（ B ）通信方式。 A. 直接通信 B. 高级通信 C. 低级通信 D. 信号量 6. 原语是（B）。
A、一条机器指令 B、若干条机器指令组成 C、一条特定指令 D、中途能打断的指令 7. 进程和程序的一个本质区别是（A）。 A．前者为动态的，后者为静态的； B．前者存储在内存，后者存储在外存； C．前者在一个文件中，后者在多个文件中； D．前者分时使用CPU,后者独占CPU。 8. 任何两个并发进程之间存在着（D）的关系。 A．各自完全独立B．拥有共享变量 C．必须互斥D．可能相互制约 9. 进程从运行态变为等待态可能由于（B ）。 A．执行了V操作 B．执行了P操作 C．时间片用完 D．有高优先级进程就绪 10. 用PV操作管理互斥使用的资源时，信号量的初值应定义为（B）。 A．任意整数 B．1 C．0 D．-1 11. 现有n个具有相关临界区的并发进程，如果某进程调用P操作后变为等待状态，则调用P操作时信号量的值必定为（A）。 A．≤0 B．1 C．n-1 D．n
查看程序的进程和线程实验报告
查看程序的进程和线程实验报告 篇一：程序实验2：11-多线程编程---实验报告 程序实验二：11-多线程编程实验 专业班级实验日期 5.21 姓名学号实验一（p284：11-thread.c） 1、软件功能描述 创建3个线程，让3个线程重用同一个执行函数，每个线程都有5次循环，可以看成5个小任务，每次循环之间会有随即等待时间（1-10s）意义在于模拟每个任务到达的时间是随机的没有任何的特定规律。 2、程序流程设计 3．部分程序代码注释(关键函数或代码) #include #include #include #define T_NUMBER 3 #define P_NUMBER 5 #define TIME 10.0
void *thrd_func(void *arg ) { (本文来自：https://www.sodocs.net/doc/658312465.html, 小草范文网:查看程序的进程和线程实验报告) int thrd_num=(int)arg; int delay_time =0; int count =0; printf("Thread %d is staraing\n",thrd_num); for(count=0;count { delay_time =(int)(rand()*TIME/(RAND_MAX))+1; sleep(delay_time); printf("\tTH%d:job%d delay =%d\n",thrd_num,count,delay_time); } printf("%d finished\n",thrd_num); pthread_exit(NULL); } int main()
操作系统--进程和线程实验报告
一.进程的创建 1．编辑源程序。 2. 编辑结果如下。 3.编译和运行程序。 4.运行解释结果 在语句p1=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了.这两个进程的几乎完全相同，将要执行的下一条语句都是if(p1==0). 而fork函数有三种返回值。（1）在父进程中，fork返回新创建子进程的进程ID； （2）在子进程中，fork返回0； （3）如果出现错误，fork返回一个负值； 所以，子进程中p1==0，输出I am child。父进程p1>0,输出I am parent。
1.编辑源程序。 2.编辑结果如下。 3.编译和运行程序。 4. 运行解释结果 在语句p1=fork()之前，只有父进程执行，putchar(‘x’)语句将x放入父进程的缓冲区。当成功创建子进程后，子进程复制父进程的缓冲区。接着子进程运行输出xby，父进程输出xay。
1.编辑源程序。 2.编辑结果如下。 3.编译和运行程序。 4. 运行解释结果 在语句p1=fork()之前，只有父进程执行，putchar(‘x’)语句将x放入父进程的缓冲区。当成功创建子进程后，子进程复制父进程的缓冲区。接着子进程输出b后，执行exit(0)系统调用终止执行。父进程输出a 后继续输出y。所以父进程输出xay而子进程输出xb。
1.编辑源程序。 2.编辑结果如下。 3.编译和运行程序。 4. 运行解释结果 语句while(p1=fork()==-1)创建了子进程和父进程。父进程执行到wait()时，等待子进程的终止信号，当子进程执行完exit(0)后，父进程才继续执行。实现了父进程等待子进程。
任务、进程和线程的区别
任务、进程和线程的区别 推荐 摘： 任务（task）是最抽象的,是一个一般性的术语,指由软件完成的一个活动。一个任务既可以是一个进程,也可以是一个线程。简而言之,它指的是一系列共同达到某一目的的操作。例如,读取数据并将数据放入内存中。这个任务可以作为一个进程来实现,也可以作为一个线程（或作为一个中断任务）来实现。 进程（process）常常被定义为程序的执行。可以把一个进程看成是一个独立的程序,在内存中有其完备的数据空间和代码空间。一个进程所拥有的数据和变量只属于它自己。 线程（thread）则是某一进程中一路单独运行的程序。也就是说,线程存在于进程之中。一个进程由一个或多个线程构成,各线程共享相同的代码和全局数据,但各有其自己的堆栈。由于堆栈是每个线程一个,所以局部变量对每一线程来说是私有的。由于所有线程共享同样的代码和全局数据,它们比进程更紧密,比单独的进程间更趋向于相互作用,线程间的相互作用更容易些,因为它们本身就有某些供通信用的共享内存：进程的全局数据。 一个进程和一个线程最显著的区别是：线程有自己的全局数据。线程存在于进程中,因此一个进程的全局变量由所有的线程共享。由于线程共享同样的系统区域,操作系统分配给一个进程的资源对该进程的所有线程都是可用的,正如全局数据可供所有线程使用一样。 简而言之,一个程序至少有一个进程,一个进程至少有一个线程。线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。从逻辑角度来看，多线程的意义在于一个应用程序中，由多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配，这就是进程和线程的重要区别。 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。 进程概念
进程和线程的CPU亲和性
进程和线程的亲缘性（affinity）是指可以将进程或者是线程强制限制在可用的CPU子集上运行的特性，它一定程度上把进程/线程在多处理器系统上的调度策略暴露给系统程序员。 CPU的数量和表示在有n个CPU的Linux上，CPU是用0...n-1来进行一一标识的。CPU的数量可以通过proc文件系统下的CPU相关文件得到，如cpuinfo和stat： $ cat /proc/stat | grep "^cpu[0-9]\+" | wc -l 8 $ cat /proc/cpuinfo | grep "^processor" | wc -l 8 在系统编程中，可以直接调用库调用sysconf获得： sysconf(_SC_NPROCESSORS_ONLN); 进程的亲缘性Linux操作系统在2.5.8引入了调度亲缘性相关的系统调用： int sched_setaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask); int sched_getaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask); 其中sched_setaffinity是设定进程号为pid的进程调度亲缘性为mask，也就是说它只能在mask中指定的CPU 之间进行调度执行;sched_getaffinity当然就是得到进程号为pid的进程调度亲缘性了。如果pid为0，则操纵当前进程。 第二个参数指定mask所指空间的大小，通常为sizeof(cpu_set_t)。 第三个参数mask的类型为cpu_set_t，即CPU集合，GNU的c库（需要在include头文件之前定义 __USE_GNU）还提供了操作它们的宏： void CPU_CLR(int cpu, cpu_set_t *set); int CPU_ISSET(int cpu, cpu_set_t *set); void CPU_SET(int cpu, cpu_set_t *set); void CPU_ZERO(cpu_set_t *set); 如果我们所关心的只是CPU#0和CPU#1，想确保我们的进程只会运作在CPU#0之上，而不会运作在CPU#1之上。下面程序代码可以完成此事： cpu_set_t set; int ret, i; CPU_ZERO(&set); CPU_SET(0, &set); CPU_CLR(1, &set); ret = sched_setaffinity(0, sizeof(cpu_set_t), &set); if( ret == -1) { perror("sched_se"); } for( i=0; i < 3; i++) { int cpu; cpu = CPU_ISSET(i, &set); printf("cpu = %i is %s/n", i, cpu? "set" : "unset"); } Linux只提供了面向线程的调度亲缘性一种接口，这也是上面只提调度亲缘性而不直言进程亲缘性的原因。当前Linux系统下广泛采用的线程库NPTL（Native Posix Thread Library）是基于线程组来实现的，同一个线程组中的线程对应于一组共享存储空间的轻量级进程，它们各自作为单独调度单位被内核的调度器在系统范围内调度，这种模型也就是我们通常所说的1-1线程模型。正因如此，目前线程的调度范围
进程和线程的选择
鱼还是熊掌：浅谈多进程多线程的选择 关于多进程和多线程，教科书上最经典的一句话是“进程是资源分配的最小单位，线程是CPU调度的最小单位”，这句话应付考试基本上够了，但如果在工作中遇到类似的选择问题，那就没有这么简单了，选的不好，会让你深受其害。 经常在网络上看到有的XDJM问“多进程好还是多线程好？”、“Linux下用多进程还是多线程？”等等期望一劳永逸的问题，我只能说：没有最好，只有更好。根据实际情况来判断，哪个更加合适就是哪个好。 我们按照多个不同的维度，来看看多线程和多进程的对比（注：因为是感性的比较，因此都是相对的，不是说一个好得不得了，另外一个差的无法忍受） 看起来比较简单，优势对比上是“线程 3.5 v 2.5 进程”，我们只管选线程就是了？ 呵呵，有这么简单我就不用在这里浪费口舌了，还是那句话，没有绝对的好与坏，只有哪个更加合适的问题。我们来看实际应用中究竟如何判断更加合适。 1）需要频繁创建销毁的优先用线程 原因请看上面的对比。 这种原则最常见的应用就是Web服务器了，来一个连接建立一个线程，断了就销毁线程，要是用进程，创建和销毁的代价是很难承受的
2）需要进行大量计算的优先使用线程 所谓大量计算，当然就是要耗费很多CPU，切换频繁了，这种情况下线程是最合适的。 这种原则最常见的是图像处理、算法处理。 3）强相关的处理用线程，弱相关的处理用进程 什么叫强相关、弱相关？理论上很难定义，给个简单的例子就明白了。 一般的Server需要完成如下任务：消息收发、消息处理。“消息收发”和“消息处理”就是弱相关的任务，而“消息处理”里面可能又分为“消息解码”、“业务处理”，这两个任务相对来说相关性就要强多了。因此“消息收发”和“消息处理”可以分进程设计，“消息解码”、“业务处理”可以分线程设计。 当然这种划分方式不是一成不变的，也可以根据实际情况进行调整。 4）可能要扩展到多机分布的用进程，多核分布的用线程 原因请看上面对比。 5）都满足需求的情况下，用你最熟悉、最拿手的方式 至于“数据共享、同步”、“编程、调试”、“可靠性”这几个维度的所谓的“复杂、简单”应该怎么取舍，我只能说：没有明确的选择方法。但我可以告诉你一个选择原则：如果多进程和多线程都能够满足要求，那么选择你最熟悉、最拿手的那个。 需要提醒的是：虽然我给了这么多的选择原则，但实际应用中基本上都是“进程+线程”的结合方式，千万不要真的陷入一种非此即彼的误区。
Linux下查看进程和线程
在Linux中查看线程数的三种方法 1、top -H 手册中说：-H : Threads toggle 加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。 2、ps xH 手册中说：H Show threads as if they were processes 这样可以查看所有存在的线程。 3、ps -mp
进程和线程的区别
进程和线程的区别 进程和线程的概念 先了解一下操作系统的一些相关概念，大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制暂停去执行下一个任务，被暂停的任务就处于就绪状态等待下一个属于它的时间片的到来。这样每个任务都能得到执行，由于CPU的执行效率非常高，时间片非常短，在各个任务之间快速地切换，给人的感觉就是多个任务在“同时进行”，这也就是我们所说的并发(并发简单来说多个任务同时执行)。 进程 计算机的核心是CPU，它承担了所有的计算任务；而操作系统是计算机的管理者，它负责任务的调度、资源的分配和管理，统领整个计算机硬件；应用程序侧是具有某种功能的程序，程序是运行于操作系统之上的。 进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序、数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块(Program Control Block，简称PCB)，包含进程的描述信息和控制信息，是进程存在的唯一标志。 进程具有的特征： 动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的； 并发性：任何进程都可以同其他进程一起并发执行； 独立性：进程是系统进行资源分配和调度的一个独立单位； 结构性：进程由程序、数据和进程控制块三部分组成。 进程的生命周期 ? 在早期只有进程的操作系统中，进程有五种状态，创建、就绪、运行、阻塞(等待)、退出。
进程和线程的管理
2. 进程和线程的管理 例题解析 例2.2.1 试说明进程和程序之间的区别和联系。 解进程和程序是既有区别又有联系的两个概念。 (1)进程是动态的，程序是静态的。程序是一组有序的指令集合，是一个静态的概念；进程则是程序及其数据在计算机上的一次执行，是一个动态的集合。离开了程序，进程就失去了存在的意义，但同一程序在计算机上的每次运行将构成不同的进程。程序可看作是电影的胶片，进程可以看作电影院放电影的过程。 (2)一个进程可以执行多个程序，如同一个电影院的一场电影可放映多部影片。 (3)一个程序可被多个进程执行，如同多个影院同时利用一个电影的胶片放映同一部电影。 (4)程序可以长期保存，进程只能存在于一段时间。程序是永久存在的，而进程有从被创建到消亡的生命周期。 例2.2.2 举例说明多道程序系统失去了封闭性和再现性。 解例如，有两个循环程序A和B，共享一个变量N。程序A每执行一次时，都要做N：=N+1操作；程序B则每执行一次时，都要执行print(N)操作，然后再将N的值置成“0”。程序A和B在多道程序系统中同时运行。假定某时刻变量N的值为n，可能出现下述三种情况： (1)N：=N+1 在print(N)和N：=0之前，此时得到N值变化过程为n+1、n+1、0； (2)N：=N+1 在print(N)和N：=0之后，此时得到N值变化过程为n 、0 、1； (3)N：=N+1 在print(N)之后和N：=0之前，此时得到N值变化过程为n、n+1、0。 所以，在A、B程序多次执行过程中，虽然其每次执行时的环境和初始条件都相同，但每次得到的结果却不一定相同。 例2.2.3 为什么将进程划分成执行、就绪和阻塞三个基本状态？ 解根据多道程序执行的特点，进程的运行是走走停停的。因此进程的初级状态应该是执行和等待状态。处于执行状态的进程占用处理机执行程序，处于等待状态的进程正在等待处理机或者等待其它某种事件的发生。但
进程与线程的区别[试题]
进程与线程的区别[试题] 进程与线程的区别: 通俗的解释 一个系统运行着很多进程，可以比喻为一条马路上有很多马车 不同的进程可以理解为不同的马车而同一辆马车可以有很多匹马来拉----这些马就是线程 假设道路的宽度恰好可以通过一辆马车道路可以认为是临界资源 那么马车成为分配资源的最小单位(进程) 而同一个马车被很多匹马驱动(线程)----即最小的运行单位 每辆马车马匹数>=1 所以马匹数=1的时候进程和线程没有严格界限，只存在一个概念上的区分度马匹数>1的时候才可以严格区分进程和线程 专业的解释: 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者《操作系统的设计与实现》。对就个问题说得比较清楚。 +++++++++++++++++++++++++++++++++++++++++++++++ 进程概念 进程是表示资源分配的基本单位，又是调度运行的基本单位。例如，用户运行自己的程序，系统就创建一个进程，并为它分配资源，包括各种表格、内存空间、磁盘空间、I,O设备等。然后，把该进程放人进程的就绪队列。进程调度程序选中它，为它分配CPU以及其它有关资源，该进程才真正运行。所以，进程是系统中的并发执行的单位。
线程与进程
1.进程与线程区别 从概念上： 进程：一个程序对一个数据集的动态执行过程，是分配资源的基本单位。 线程：一个进程内的基本调度单位。 线程的划分尺度小于进程，一个进程包含一个或者更多的线程。 从执行过程中来看： 进程：拥有独立的内存单元，而多个线程共享内存，从而提高了应用程序的运行效率。 线程：每一个独立的线程，都有一个程序运行的入口、顺序执行序列、和程序的出口。但是线程不能够独立的执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看：（重要区别） 多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但是，操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理及资源分配。 2.我们写的程序，不论是C、C++、java还是其他的，其实都是一种文本，真正 运行、跑动的是进程。 程序可以分为两部分：源代码和可执行的二进制代码（经过汇编或编译）。操作系统加载这个可执行的二进制代码后，还要分配相应的内核数据结构——进程控制块（PCB：process control block），并进行一系列的初始化等过程（如：创建PID、分配时间片等）后才创建了真正可以“跑动”的进程。所以程序相当于是一个项目的计划书（或行动方案），而进程才是对该方案的实施过程。 进程对CPU来说其实就是一串可执行的指令序列，这个执行序列也叫执行线程，它是进程的控制流程。传统的用户进程只有一个执行流程，所以传统的进程都是单线程的。有了线程就是执行流程的概念后，进程模型得到了扩展，因为一个进程中完全可以设置多个执行流程，即多个执行线程。所以一个进程中可以创建多个线程，当然不创建的话，进程本身也可以看成是线程。 创建多个进程的话，每个进程都是独立的（都有自己独立的PCB数据结构，该数据结构比较大，将近1K的信息量，包括唯一的PID、上下文环境、持有的内存地址等等），内核要管理进程间的切换、内存管理等，开销相对比较大。 如果一个进程里创建多个线程的话，开销比进程要小，各线程共享进程的状态和资源，内核为线程创建的数据结构相对比进程的PCB就要小的多，当然额外的开销是CPU需要跟踪线程，同时线程间存在争用资源的问题。如果程序要完成一组相关任务，则用线程比较好。 下面再细讲下进程：
实验一 熟悉Windows2000XP中的进程和线程
实验一熟悉Windows2000/XP中的进程和线程 一、实验目的 1、熟悉Windows2000/XP中任务管理器的使用。 2、通过任务管理器识别操作系统中的进程和线程的相关信息。 3、掌握利用spy++.exe来察看Windows中各个任务的更详细信息。 二、实验理论基础及教材对应关系 1、实验理论基础： （1）操作系统中的进程和线程的概念； （2）进程PCB的各项指标含意； 2、本实验内容主要对应于教材第2章。 三、实验内容与步骤 1、启动操作系统自带的任务管理器： 方法：直接按组合键Ctrl+Alt+Del，或者是在点击任务条上的“开始”“运行”，并输入“taskmgr.exe”。如下图所示：
2、调整任务管理器的“查看”中的相关设置，显示关于进程的以下各项信息，并完成 下表（填满即可）： 表一：统计进程的各项主要信息 3、从桌面启动办公软件“Word”，在任务管理器中找到该软件的登记，并将其结束掉。
再从任务管理器中分别找到下列程序：winlogon.exe、lsass.exe、csrss.exe、smss.exe，试着结束它们，观察到的反应是图标消失机器关机，原因是系统文件。 4、在任务管理器中找到进程“explorer.exe”，将之结束掉，并将桌面上你打开的所 有窗口最小化，看看你的计算机系统起来什么样的变化桌面图标、开始任务栏消失、得到的结论是任务栏、桌面应用（说出explorer.exe进程的作用）。 5、运行“spy++.exe”应用软件，点击按钮“”，切换到进程显示栏上，查看进程“explorer.exe”的各项信息，并填写下表： 表二：统计线程的各项信息 进程：explorer.exe 中的各个线程
Windows进程与线程
实验一Windows进程与线程 1.实验内容 观察Window进程、线程关键数据结构 实验环境： 主机Windows 7 目标机 Windows Server 2003 SP1 （虚拟机） Windbg 工具 2.理论基础 Windows系统内部有执行体对象和内核对象两种类型，执行体对象由执行体的各种组件，如进程管理器所实现，内核对象由Windows内核实现，其更为基础。Windows中的进程和线程在执行体中以对象的方式实现。 一个进程主要由几个部分组成，其中包括一个私有的虚拟地址空间，一个可执行的程序，一个已打开的句柄列表，一个称为访问令牌的安全环境，一个唯一标识，至少一个执行线程。 NOTS中每个进程有5个数据结构： EPROCESS,KPROCESS,PEB,WIN32KPROCESS,子系统csrss为每个win用户进程创建的进程信息数据结构。 线程是一个进程的内部实体，NTOS中每个线程也有5个数据结构： ETHREAD,KTHREAD,TEB,WIN32THREAD,csrss为每个线程建立的线程信息数据结构 3.实验步骤 搭建好实验环境，配置完成后在目标机里运行实验程序test.exe ，中断，在Windbg中Commad窗口输入!process 0 0，如下图，最后一项为测试程序信息。可知其虚地址为813d1948.
其EPROCESS 如下图
查看其偏移0x000处KPROCESS 结构的具体信息
查看进程环境块PEB 信息
查看其线程ETHREAD 结构信息
查看的ThreadsProcess 为 0x813d1948，也就是进程test.exe 的虚地址 继续查看KTHREAD 的信息，如下 kd> dt_kthread 813db4c0 nt!_KTHREAD +0x000 Header : _DISPATCHER_HEADER +0x010 MutantListHead : _LIST_ENTRY [ 0x813db4d0 - 0x813db4d0 ] +0x018 InitialStack : 0xfa0ec000 +0x01c StackLimit : 0xfa0e9000 +0x020 KernelStack : 0xfa0ebd44 +0x024 ThreadLock : 0 +0x028 ApcState : _KAPC_STATE +0x028 ApcStateFill : [23] "???" +0x03f ApcQueueable : 0x1 '' +0x040 NextProcessor : 0 '' +0x041 DeferredProcessor : 0 ''
操作系统第2章(进程和线程的管理习题及解答)
第2章进程和线程的管理习题及解答 例题解析 例2.2.1 试说明进程和程序之间的区别和联系。 解进程和程序是既有区别又有联系的两个概念。 (1)进程是动态的，程序是静态的。程序是一组有序的指令集合，是一个静态的概念；进程则是程序及其数据在计算机上的一次执行，是一个动态的集合。离开了程序，进程就失去了存在的意义，但同一程序在计算机上的每次运行将构成不同的进程。程序可看作是电影的胶片，进程可以看作电影院放电影的过程。 (2)一个进程可以执行多个程序，如同一个电影院的一场电影可放映多部影片。 (3)一个程序可被多个进程执行，如同多个影院同时利用一个电影的胶片放映同一部电影。 (4)程序可以长期保存，进程只能存在于一段时间。程序是永久存在的，而进程有从被创建到消亡的生命周期。 例2.2.2 举例说明多道程序系统失去了封闭性和再现性。 解例如，有两个循环程序A和B，共享一个变量N。程序A每执行一次时，都要做N：=N+1操作；程序B则每执行一次时，都要执行print(N)操作，然后再将N的值置成“0”。程序A和B在多道程序系统中同时运行。假定某时刻变量N的值为n，可能出现下述三种情况： (1)N：=N+1 在print(N)和N：=0之前，此时得到N值变化过程为n+1、n+1、0； (2)N：=N+1 在print(N)和N：=0之后，此时得到N值变化过程为n 、 0 、1； (3)N：=N+1 在print(N)之后和N：=0之前，此时得到N
值变化过程为n、n+1、0。 所以，在A、B程序多次执行过程中，虽然其每次执行时的环境 和初始条件都相同，但每次得到的结果却不一定相同。 例 2.2.3 为什么将进程划分成执行、就绪和阻塞三个基本状态？ 解根据多道程序执行的特点，进程的运行是走走停停的。因此 进程的初级状态应该是执行和等待状态。处于执行状态的进程占用 处理机执行程序，处于等待状态的进程正在等待处理机或者等待其 它某种事件的发生。但是，当处理机空闲时，并不是所有处于等待 状态的进程都能放到处理机上执行，有的进程即使分配给它处理机，它也不能执行，因为它的执行的条件没有得到满足。因此，将等待 状态的进程分成两部分，一部分是放在处理机上就能立即执行，这 就是就绪的进程；另一部分是仍需等某种事件发生的进程，即使放 在处理机上也不能执行的进程，这就是阻塞进程。 例 2.2.4 进程的挂起状态与进程的阻塞状态和就绪状态有何异同？ 解相同点是它们都没有占用处理机。不同点是挂起状态的进程 是处于一种静止状态，不会参与对资源的竞争，在解除挂起之前， 进程不会有新的资源要求，也不会有占用处理机的机会；阻塞状态 和就绪状态的进程均处于活动状态，它们都有获得处理机的机会， 都可能有新的资源要求。 例 2.2.5 两个并发进程P1和P2的程序代码在下面给出。其中，A、B、C、D和E均为原语。 P1: begin P2: begin
CPU进程与线程的关系和区别
CPU进程与线程的关系和区别 篇一：进程和线程的区别 进程和线程的区别线程是指进程内的一个执行单元,也是进程内的可调度实体. 与进程的区别: (1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间; (2)资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源 (3)线程是处理器调度的基本单位,但进程不是. 4)二者均可并发执行. 进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程，使得多线程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是cpu调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行. 和"stdio.h"区别 #include"stdio.h" 当要调用某个函数时 先在用户自已编写的文件中查找，如果找不到再到库文件里去找，而#include是直接到库文件里去找 所以如果是调用自己写的函数的话就用#include"stdio.h",这种形式 而调用标准库函数的话就用#include这种形式，可以提高速度 篇二：进程线程区别与联系 定义： 一程序只是一组指令的有序集合
线程和进程基本概念
多核并行计算 并行计算或称平行计算是相对于串行计算来说的。所谓并行计算可分为时间上的并行和空间上的并行。而空间上的并行则是指用多个处理器并发的执行计算。 并行计算（Parallel Computing）是指同时使用多种计算资源解决计算问题的过程，是提高计算机系统计算速度和处理能力的一种有效手段。它的基本思想是用多个处理器来协同求解同一问题，即将被求解的问题分解成若干个部分，各部分均由一个独立的处理机来并行计算。 1进程 进程是操作系统结构的基础；进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源，是一个动态的概念，是一个活动的实体。它不只是程序的代码，还包括当前的活动，通过程序计数器的值和处理寄存器的内容来表示。 进程定义： 广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 狭义定义：进程就是一段程序的执行过程。即是一个正在执行应用程序。
进程的概念主要有两点： 第一，进程是一个实体。每一个进程都有它自己的独立的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。 第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。 特征 动态性：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的。 并发性：任何进程都可以同其他进程一起并发执行 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位；
进程和线程中英文
进程和线程简介（中英文） Programs consist of a number of processes, each of which contains one or more conceptually concurrent threads of execution. 程序包含了若干进程，每一个进程包含了一个或多个概念上知执行的线程。 A thread is the unit of execution within a process. Every time a process is initialised, a primary thread is created. For many applications the primary thread is the only one that the application requires; however, processes can create additional threads. 线程是进程的执行单元。当进程被初始化后，主线程就被创建了。对于绝大多数的应用程序来说，通常仅要求有一个主线程。尽管如此进程也可以创建额外的线程。 Each user process has its own private address space, i.e. a collection of memory regions which that process can access. A user process cannot directly address memory areas in the address space of another process. There is also a special process, the Kernel process, whose threads run at supervisor privilege level. This process normally contains two threads: 每一个用户进程拥有自己私有的地址空间，也就是说，进程拥有一定的可被其访问的内存区域。一个用户进程不可以直接访问其他进程的地址空间。另外还有一个特殊的进程,内核进程，它运行在超级用户权限模式。这个进程通常包括两个线程： the Kernel server thread, which is the initial thread whose execution begins at the reset vector, and which is used to implement all Kernel functions requiring allocation or deallocation on the Kernel heap. This is the highest priority thread in the system. Kernel server （内核服务器）线程：是一个初始的进程，在系统启动时就已经存在。它可以在heap执行由核心函数请求的内存分配或内存的重分配。这是系统中具有最高权限的线程。 the null thread, which runs only when no other threads are ready to run. The null thread places the processor into idle mode to save power. null （空）线程：当系统中没有其他可运行的线程时这个线程就开始运行，null 线程使处理器处于空闲状态，减少耗电。 Threads execute individually and are unaware of other threads in a process. The scheduling of threads is pre-emptive, i.e. a currently executing thread may be suspended at any time to allow another thread to run.