线程和进程的比较
操作系统中的进程、线程与Java的多线程
动 态概 念 ， 有动 态 属 性 ， 一 个 进 程 都是 具 每
由 内 核 对 象 和 地 址 空 间 所 组 成 的 ， 核对 内
据 以 及 线 程 堆 栈 、 分 配 空 间 等 动 态 分 配 堆
的空间 。
ｅ ｊ ｖ ， ａ ａｙ ｉ ｇ ｒ ｍ ｈ ｂ ｓｃ ｏ ｃ ｐ ｏ ｔ ｅ ｒｃ ｓ ｄ ａａ ｎ ｌｚ ｎ ｆ ｏ ｔ ｅ ａ ｉ ｃ ｎ ｅ ｔ ｆ ｈ ｐ ｏ ｅｓ， ｔ ｅ ｄ ｎ ａ ｄ ｈｒａ ｉ ｇ ｎ ｍｕ ｔ－ｔ ｅ ｄ ｎ ， ｄ ｍｏ ｓｒ ｔｏ ａ ｅ ｌｏ ｆｅ ｅ ｏ ｈ ｗ ｔ ｌｉ ｈｒａ ｉ ｇ ｅ ｎ ｔａ ｉｎｓ ｒ ａｓ ｏ ｆ ｒｄ ｓ ｏ ｈ
Ａｂ ｔ ａ ｔ Ｔｈｉ ｐ ｐ ｒ ｅ ｏ ｔ ａ ｔ ｄ ｏ ｄ ｔ ｉｅ ｅ ｐ ｓ ｔ ｏ ｓ ｂ ｕｔ ｈ ｒ ｌ ｔｏ ｓ ｐ ｍｏ ｇ ｈ ｐ ｏ ｅ ｓ ， ｔ ｅ ｄｉ ａ ｄ ｓｒｃ ： ｓ ａ ｅ ｒ ｐ ｒ ｓ ｓ ｕ ｙ ｎ ｅ ａ ｌ ｄ ｘ ｏ ｉ ｉ ｎ ａ ｏ ｔ ｅ ｅ ａ ｉ ｎ ｈｉ ａ ｎ ｔ ｅ ｒ ｃ ｓ ｈｒ ａ ｎｇ ｎ ｍｕ ｔ －ｔ ｅ ｄ ｌ ｉ ｈｒ ａ
ｅ ａ ｐ ｉ ａ ｉ ｎ ｏ ｔ ｒ ａ ｉ ｔ ｅ ｐ ｏ ｅ ｕｒ ｓ ａ ａ， ｒ ａ ｉ ｎ ｏ ｔ ｅ ｄ ｎｇ ａ ｄ ｒ ｎ ｎ ｐ ｌｃ ｔｏ ｓ ｆ ｈ ｅ ｄ ｎ ｈ ｒ ｃ ｄ ｅ Ｊ ｖ ｃ ｅ ｔ ｏ ｆ ｈｒ ａ ｉ ｎ ｕ ｎｉ ｇ．
程 。
中， 是一个Ｅ 就 ＸＥ文 件 的 执 行 过 程 。 一 个 是
址 空 间 则 包 括 了所 有 程 序 模 块 的 代 码 和数
多线程和多进程的区别（C++）
多线程和多进程的区别（C++）很想写点关于多进程和多线程的东西，我确实很爱他们。
但是每每想动⼿写点关于他们的东西，却总是求全⼼理作祟，始终动不了⼿。
今天终于下了决⼼，写点东西，以后可以再修修补补也⽆妨。
⼀.为何需要多进程（或者多线程），为何需要并发？这个问题或许本⾝都不是个问题。
但是对于没有接触过多进程编程的朋友来说，他们确实⽆法感受到并发的魅⼒以及必要性。
我想，只要你不是整天都写那种int main()到底的代码的⼈，那么或多或少你会遇到代码响应不够⽤的情况，也应该有尝过并发编程的甜头。
就像⼀个快餐点的服务员，既要在前台接待客户点餐，⼜要接电话送外卖，没有分⾝术肯定会忙得你焦头烂额的。
幸运的是确实有这么⼀种技术，让你可以像孙悟空⼀样分⾝，灵魂出窍，乐哉乐哉地轻松应付⼀切状况,这就是多进程/线程技术。
并发技术，就是可以让你在同⼀时间同时执⾏多条任务的技术。
你的代码将不仅仅是从上到下，从左到右这样规规矩矩的⼀条线执⾏。
你可以⼀条线在main函数⾥跟你的客户交流，另⼀条线，你早就把你外卖送到了其他客户的⼿⾥。
所以，为何需要并发？因为我们需要更强⼤的功能，提供更多的服务，所以并发，必不可少。
⼆.多进程什么是进程。
最直观的就是⼀个个pid,官⽅的说法就：进程是程序在计算机上的⼀次执⾏活动。
说得简单点，下⾯这段代码执⾏的时候[cpp]1. int main()2.3. {4.5. printf(”pid is %d/n”,getpid() );6.7. return 0;8.9. }进⼊main函数，这就是⼀个进程，进程pid会打印出来，然后运⾏到return，该函数就退出，然后由于该函数是该进程的唯⼀的⼀次执⾏，所以return后，该进程也会退出。
看看多进程。
linux下创建⼦进程的调⽤是fork();[cpp]1. #include <unistd.h>2. #include <sys/types.h>3. #include <stdio.h>4.5.6.7. void print_exit()8. {9. printf("the exit pid:%d/n",getpid() );10. }11.12. main ()13. {14. pid_t pid;15. atexit( print_exit ); //注册该进程退出时的回调函数16. pid=fork();17. if (pid < 0)18. printf("error in fork!");19. else if (pid == 0)20. printf("i am the child process, my process id is %d/n",getpid());21. else22. {23. printf("i am the parent process, my process id is %d/n",getpid());24. sleep(2);25. wait();26. }27.28. }i am the child process, my process id is 15806the exit pid:15806i am the parent process, my process id is 15805the exit pid:15805这是gcc测试下的运⾏结果。
进程与线程
进程与线程上篇进程在操作系统中是最基本、最重要的概念。
在概念上看，进程主要有两点：第一，进程是一个实体。
每一个进程都有它自己的地址空间，一般情况下，包括文本区域、数据区域和堆栈。
文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
第二，进程是一个“执行中的程序”。
程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。
进程是在多道程序系统出现后，为了刻画系统内部的动态状况、描述运行程序的活动规律而引起的新概念，所有多道程序设计操作系统都建立在进程的基础之上。
在操作系统中引入进程可以刻画系统的动态性、发挥系统的并发性，而且可以解决共享性，正确的描述程序执行状态。
在特征上看，进程的特征主要有结构性、共享性、动态性、并发性、独立性与制约性。
进程包含数据集合和运行于其上的程序，它至少由程序块、数据块和进程控制块等要素组成，因此具有结构性。
动态性是指：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的。
而并发性是指：任何进程都可以同其他进程一起并发执行。
进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位，因此具有独立性。
由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进，所以进程是具有制约性的。
按照进程在执行过程中的不同情况至少要定义三种进程状态：首先是运行态，运行态是指进程占用处理器的状态。
其次是就绪态，进程具备运行条件，等待系统分配处理器以便其运行状态，最后是等待态又称阻塞态或睡眠态，是指进程不具备运行条件，正在等待某个事件完成的状态。
在我们的计算机的操作系统中存在很多进程，而这些进程可以在任务管理器中查看。
如下图。
在我们的计算机中的浏览器、QQ等应用程序的使用都可以称作一个进程，而且配置鼠标的应用程序也属于进程。
Python的多线程（threading）与多进程（multiprocessing）
Python的多线程（threading）与多进程（multiprocessing）进程：程序的⼀次执⾏（程序载⼊内存，系统分配资源运⾏）。
每个进程有⾃⼰的内存空间，数据栈等，进程之间可以进⾏通讯，但是不能共享信息。
线程：所有的线程运⾏在同⼀个进程中，共享相同的运⾏环境。
每个独⽴的线程有⼀个程序⼊⼝，顺序执⾏序列和程序的出⼝。
线程的运⾏可以被强占，中断或者暂时被挂起（睡眠），让其他的线程运⾏。
⼀个进程中的各个线程共享同⼀⽚数据空间。
多线程import threadingdef thread_job():print "this is added thread,number is {}".format(threading.current_thread())def main():added_thread = threading.Thread(target = thread_job) #添加线程added_thread.start() #执⾏添加的线程print threading.active_count() #当前已被激活的线程的数⽬print threading.enumerate() #激活的是哪些线程print threading.current_thread() #正在运⾏的是哪些线程if __name__ == "__main__":main()this is added thread,number is <Thread(Thread-6, started 6244)>6[<HistorySavingThread(IPythonHistorySavingThread, started 7588)>, <ParentPollerWindows(Thread-3, started daemon 3364)>, <Heartbeat(Thread-5, started daemon 3056)>, <_MainThread(MainThread, started 1528)>, <Thread(Thread-6, started <_MainThread(MainThread, started 1528)>#join 功能等到线程执⾏完之后再回到主线程中去import threadingimport timedef T1_job():print "T1 start\n"for i in range(10):time.sleep(0.1)print "T1 finish"def T2_job():print 'T2 start'print 'T2 finish'def main():thread1 = threading.Thread(target = T1_job) #添加线程thread2 = threading.Thread(target = T2_job)thread1.start() #执⾏添加的线程thread2.start()thread1.join()thread2.join()print 'all done\n'if __name__ == "__main__":main()T1 startT2 startT2 finishT1 finishall done#queue 多线程各个线程的运算的值放到⼀个队列中，到主线程的时候再拿出来,以此来代替#return的功能，因为在线程是不能返回⼀个值的import timeimport threadingfrom Queue import Queuedef job(l,q):q.put([i**2 for i in l])def multithreading(data):q = Queue()threads = []for i in xrange(4):t = threading.Thread(target = job,args = (data[i],q))t.start()threads.append(t)for thread in threads:thread.join()results = []for _ in range(4):results.append(q.get())print resultsif __name__ == "__main__":data = [[1,2,3],[4,5,6],[3,4,3],[5,5,5]]multithreading(data)[[1, 4, 9], [16, 25, 36], [9, 16, 9], [25, 25, 25]]#多线程的锁import threadingimport timedef T1_job():global A,locklock.acquire()for i in xrange(10):A += 1print 'T1_job',Alock.release()def T2_job():global A,locklock.acquire()for i in xrange(10):A += 10print 'T2_job',Aif __name__ == "__main__":lock = threading.Lock()A = 0 #全局变量thread1 = threading.Thread(target = T1_job) #添加线程thread2 = threading.Thread(target = T2_job)thread1.start() #执⾏添加的线程thread2.start()thread1.join()thread2.join() 全局解释器锁ＧＩＬ（Global Interpreter Lock）GIL并不是Python的特性，他是CPython引⼊的概念，是⼀个全局排他锁。
程序与进程的区别
进程：是可以并发执行的程序在某个数据集合上的运行过程，是系统进行资源分配和调度的独立单位
线程：指进程中的一条执行路径，是系统进行处理器调度的基本单位，同一个进程中的所有线程共享进程获得的主存空间和资源
进程和线程比较：1调度性：线程是独立调度和分配的基本单位。
2并发性：线程具有更高的并发性。
3拥有资源：线程仅有少量运行必须的资源，进程是拥有资源的单位。
4系统开销：线程的系统开销更小
（以前学操作系统时的笔记，希望对你有用
1)程序只是一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体。
而进程则不同，它是程序在某个数据集上的执行。
进程是一个动态的实体，它有自己的生命周期。
它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。
反映了一个程序在一定的数据集上运行的全部动态过程。
2)进程和程序并不是一一对应的，一个程序执行在不同的数据集上就成为不同的进程，可以用进程控制块来唯一地标识每个进程。
而这一点正是程序无法做到的，由于程序没有和数据产生直接的联系，既使是执行不同的数据的程序，他们的指令的集合依然是一样的，所以无法唯一地标识出这些运行于不同数据集上的程序。
一般来说，一个进程肯定有一个与之对应的程序，而且只有一个。
而一个程序有可能没有与之对应的进程(因为它没有执行),也有可能有多个进程与之对应(运行在几个不同的数据集上)。
3)进程还具有并发性和交往性，这也与程序的封闭性不同。
指令,程序,进程,线程的概念及其之间的关系
指令,程序,进程,线程的概念及其之间的关系指令（Instruction）是计算机执行特定操作的命令。
它是由一系列位(Value)组成的，在计算机处理器中表示为二进制代码。
计算机通过执行一条指令，完成特定的操作，如算数运算、内存读取、数据传输等。
指令是计算机硬件和软件之间的桥梁，它告诉计算机硬件如何执行某项功能。
程序（Program）是一组有序的指令集合，通过执行这组指令，可以实现预定的计算机功能。
程序一般由程序员使用编程语言编写，并保存在磁盘或存储器中。
程序包含了实现特定功能的算法和逻辑结构。
当用户需要计算机执行某项任务时，可以通过调用相应的程序来完成。
程序可以是操作系统、应用程序、驱动程序等。
进程（Process）是指正在运行的一个程序的实例。
当一个程序被调用执行时，计算机系统会为该程序分配一些资源，如CPU时间、内存空间、文件句柄等，形成一个独立的执行环境，即进程。
进程是操作系统进行资源分配和调度的基本单位。
每个进程都有自己的地址空间和执行状态，并与其他进程相互独立、互不干扰。
进程可以同时执行多个任务，通过操作系统的调度机制，使得多个进程能够并发执行。
线程（Thread）是指进程中的一个执行单元。
一个进程可以包含多个线程，这些线程共享进程的资源，如内存、打开的文件等。
线程拥有自己的栈空间，以及指令执行顺序、程序计数器等。
多线程的机制使得多个线程能够在同一个进程中并发执行，提高系统的并发处理能力。
线程的调度由操作系统负责，通过时间分片等算法，实现不同线程之间的切换和并发执行。
指令、程序、进程和线程之间存在着以下关系：1.指令是程序的基本组成单位，程序是由一系列指令构成的。
程序是静态的，存储在磁盘或存储器中，通过调用执行。
2.程序是进程的载体，进程是程序的一次执行过程。
进程是动态的，是程序在计算机中运行的状态。
进程可以同时运行多个线程，完成多个任务。
3.线程是进程中的一个执行单元，多个线程共享进程的资源。
指令,程序,进程,线程的概念及其之间的关系
指令,程序,进程,线程的概念及其之间的关系指令、程序、进程和线程是计算机领域常用的概念，它们之间具有明确的关系。
首先，指令是计算机中的最基本操作单位，用于执行特定的功能或操作。
计算机按照指令的顺序执行程序的每个步骤，从而完成特定的任务。
指令可以是计算、数据移动、数据存储、控制等。
通常，每条指令由操作码和操作数组成，操作码表示要执行的操作，操作数表示操作的对象。
程序是一组按照特定顺序排列的指令集合，用于实现某个特定的功能或完成一项任务。
程序通常由程序员编写，在计算机上运行。
程序可以包含多个功能模块，每个功能模块负责特定的操作或任务。
程序还可以包含各种语句、变量、函数等，用于实现复杂的逻辑和算法。
进程是计算机中正在运行的程序的实例。
在操作系统中，进程是资源分配的最小单位，它拥有自己的地址空间、代码区、数据区和文件描述符等。
每个进程都是相互独立的，拥有自己的执行环境，可以独立运行和终止。
在多任务系统中，操作系统会调度多个进程，分配给每个进程一定的CPU时间片，使得多个进程可以并发执行。
线程是进程中的一个独立执行单元，也是CPU调度的最小单位。
一个进程可以包含多个线程，这些线程共享进程的地址空间和资源。
线程间可以通过共享内存或消息等方式进行通信。
由于线程较进程更轻量级，线程的切换和调度开销较小，能更高效地并发执行。
指令、程序、进程和线程的关系如下：-一个程序由一组指令构成，指令定义了程序的操作和功能。
-一个进程是一个正在运行的程序的实例，进程拥有自己的地址空间和资源。
-一个进程可以包含多个线程，这些线程共享进程的地址空间和资源。
-一个线程是进程中的一个独立执行单元，多个线程可以并发执行。
指令、程序、进程和线程的关系可以用以下的图示来表示：程序--(编译、链接)-->进程--(调度、执行)-->线程--(执行)-->指令。
在实际应用中，指令、程序、进程和线程的概念相互依存，发挥着不同的作用：-指令定义了程序的操作和功能，是程序执行的最基本指令。
进程、线程、协程之概念理解+线程和进程各自有什么区别和优劣
进程、线程、协程之概念理解+线程和进程各⾃有什么区别和优劣⼀、概念⾸先，根据图了解⼀下串⾏，并⾏和并发的基本概念： 1、进程 资源分配的基本单位进程（Process）是计算机中的程序关于某数据集合上的⼀次运⾏活动，是系统进⾏资源分配和调度的基本单位，是操作系统结构的基础。
在早期⾯向进程设计的计算机结构中，进程是程序的基本执⾏实体；在当代⾯向线程设计的计算机结构中，进程是线程的容器。
程序是指令、数据及其组织形式的描述，进程是程序的实体。
Linux系统函数fork（）可在⽗进程中创建⼀个⼦进程，在⽗进程接到新请求时，复制出⼀个⼦进程来处理，即⽗进程监控请求，⼦进程处理，实现并发处理。
注意：必须是Linux系统，windows不能⽤fork。
组成进程是⼀个实体。
每⼀个进程都有它⾃⼰的地址空间，⼀般情况下，包括⽂本区域（text region）、数据区域（data region）和堆栈（stack region）。
⽂本区域存储处理器执⾏的代码；数据区域存储变量和进程执⾏期间使⽤的动态分配的内存；堆栈区域存储着活动过程调⽤的指令和本地变量。
特征动态性：进程的实质是程序在多道程序系统中的⼀次执⾏过程，进程是动态产⽣，动态消亡的。
并发性：任何进程都可以同其他进程⼀起并发执⾏独⽴性：进程是⼀个能独⽴运⾏的基本单位，同时也是系统分配资源和调度的独⽴单位；异步性：由于进程间的相互制约，使进程具有执⾏的间断性，即进程按各⾃独⽴的、不可预知的速度向前推进结构特征：进程由程序、数据和进程控制块三部分组成。
多个不同的进程可以包含相同的程序：⼀个程序在不同的数据集⾥就构成不同的进程，能得到不同的结果；但是执⾏过程中，程序不能发⽣改变。
进程的⼏种状态（1）run（运⾏状态）：正在运⾏的进程或在等待队列中等待的进程，等待的进程只要以得到cpu就可以运⾏（2）Sleep（可中断休眠状态）：相当于阻塞或在等待的状态（3）D（不可中断休眠状态）：在磁盘上的进程（4）T（停⽌状态）：这中状态⽆法直观的看见，因为是进程停⽌后就释放了资源，所以不会留在linux中（5）Z（僵⼫状态）：⼦进程先与⽗进程结束，但⽗进程没有调⽤wait或waitpid来回收⼦进程的资源，所以⼦进程就成了僵⼫进程，如果⽗进程结束后任然没有回收⼦进程的资源，那么1号进程将回收 2、线程 CPU调度和分配的基本单位，程序执⾏的最⼩单位。
进程、线程与任务程序之间的关系
进程、线程与任务程序之间的关系1,Aplication ⼀个.apk包就可以称⼀个application,⼀般application会有很多Activity 或其他service组成。
2，task：完成⽤户的⼀个⽬的的所有activity 组成⼀个task.提到task就该提到task stack任务栈也有⼈叫活动栈。
Android系统⽤⼀个栈来记录⼀个任务，既然⼀个任务是由许多activity组成的，那栈⾥存的就是所有的 activity。
为什么需要记录呢？因为记录可以通过按back 键回到上⼀个activity.这也是为什么我们按back键可以回到上⼀个活动的原因。
那么什么时会开启⼀个新的任务呢？A)Notification 启动Activity会开启⼀个task,因为通过notification开启activity之后不需要返回到notification,所以需要开启⼀个新的task,这就是为什么我们在nofication⾥⾯启动⼀个Activity需要设置Intent的Flag为 Intent.FLAG_ACTIVITY_NEW_TASK.3,explicit intent 是明确指定启动哪个Activity，⽐如 Intent intent= new Intent(ActivityA.this, ActivityB.class).⽽implicit intent并不明确指定启动那个Activity,⽽是通过设置⼀些Intent Filter来让系统去帅选合适的activity来处理。
为什么需要分这两种Intent呢？我觉得好处有两个：第⼀，Activity 的重⽤，当⼀个Activity在其manifest⾥设置了许多intent filter，当发⽣了implicit intent时，系统就会去匹配这些filter，是否符合⽬标。
所以在设计Activity的时候就要考虑到是否重⽤问题，若需要重⽤就要设置 intent filter. 第⼆，Implicit intent可以让⽤户选择⾃⼰喜欢的Activity来处理。
操作系统第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 为什么将进程划分成执行、就绪和阻塞三个基本状态？解根据多道程序执行的特点，进程的运行是走走停停的。
因此进程的初级状态应该是执行和等待状态。
处于执行状态的进程占用处理机执行程序，处于等待状态的进程正在等待处理机或者等待其它某种事件的发生。
但是，当处理机空闲时，并不是所有处于等待状态的进程都能放到处理机上执行，有的进程即使分配给它处理机，它也不能执行，因为它的执行的条件没有得到满足。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
线程和进程的比较
1．概念分析
进程是资源分配的基本单位。所有与该进程有关的资源，都被记录在进程控
制块PCB中。以表示该进程拥有这些资源或正在使用它们。
另外，进程也是抢占处理机的调度单位，它拥有一个完整的虚拟地址空间。
与进程相对应，线程与资源分配无关，它属于某一个进程，并与进程内的其
他线程一起共享进程的资源。
当进程发生调度时，不同的进程拥有不同的虚拟地址空间，而同一进程内的
不同线程共享同一地址空间。
线程只由相关堆栈（系统栈或用户栈）寄存器和线程控制表TCB组成。寄
存器可被用来存储线程内的局部变量，但不能存储其他线程的相关变量。
发生进程切换与发生线程切换时相比较，进程切换时涉及到有关资源指针的
保存以及地址空间的变化等问题；线程切换时，由于同不进程内的线程共享资源
和地址 空间，将不涉及资源信息的保存和地址变化问题，从而减少了操作系统
的开销时间。而且，进程的调度与切换都是由操作系统内核完成，而线程则既可
由操作系统内 核完成，也可由用户程序进行
2．说明
进程的特点：
1、进程之间互不影响
2、独立的地址空间
所以我觉得目前大多数实时操作系统（我所接触的nucleus、rtems、ucos）
都是单进程多线程（任务）的，据说Vxworks有多进程的版本。
说明1：
thread和进程的区别之一：thread共享全局变量，而进程则有自己的全局变量空
间。
我见过的RTOS构成的系统，各task是共享全局变量的，同时build成一个image
的，因而有人认为rtos的系统只有thread，我看就是这么回事。
说明2：
线程thread,是从内核调度器的眼中看的，不管你给他起什么名字，只要它没有自
己的独立的memory空间，那么它就是thread，RTOS的task，一般就是thread。
什么时候会出现进程：
当thread创建自己的memory空间，因而独立于其它的thread，其它thread的
context中，不可以看到该thread了，那么这个thread就接近进程了。
进程的切换，和thread的切换，调度器做的事情是有些差异的，因为进程还要切
换memory空间。
进程有自己的全局变量，因为它有自己的memory空间，进程相互看不到别的进
程的全局变量。