‘壹’ 一个处理器上可以有多个进程吗
. 进程管理
（1） 进程与程序的区别
程序
进程
是一组有序的指令集，是一个静态的概念；同一个程序可以被几个进程同时执行；程序可以作为一种软件资源长期保存；程序是进程运行的静态文本，没有程序就没有进程。
是程序的一次执行过程，是一个动态的概念；一个进程可以执行一个或几个程序；进程只是一次执行活动，是暂时的。操作系统可以为一个作业创建一个或多个进程。 进程可以并行运行。
（2） 处理机状态：CPU在交替执行操作系统和用户程序时，根据所运行程序对机器指令的使用权限（操作系统可使用特权指令，用户程序只能使用非特权指令），将处理机设置为两种状态：
管理态（又称核心态、管态、特权态）：此时程序不受硬件限制，可执行操作系统的全集，可访问全部存储器和寄存器。操作系统一般在此态运行。
用户态（又称目标态、目态、普通态、问题态）：由于受硬件的限制，程序只能执行非特权指令，访问有限的存储空间和指定的寄存器。用户程序通常都在此态下运行。
（3）进程的状态
就绪态：指进入内存的进程准备就绪，等待获得CPU的状态（即已具备运行条件，但因CPU被别的进程占用，暂时不能运行）。
系统中处于就绪态的进程可以有多个。
运行态：当一个进程已分配到处理机，它的程序正由处理机执行着的状态。
阻塞态：进程因等待某一件事情（如等待I/O设备）而暂时不能运行的状态，此时即使处理机空闲，进程也无法使用。系统中处于阻塞态（又称封锁态、等待态、睡眠态）的进程也可以有多个。
（4）进程的组成
程序： 描述了进程所要完成的功能。 是进程存在的物质基础。
数据： 是程序加工的对象。
进程控制块PCB：用来描述进程的一切静态和动态的特征，操作系统只能通过它来感知和管理进程。每个进程都有且仅有一个进程控制块。
进程控制块的内容：PCB的具体内容随不同系统而异，一般包括以下信息：
· 进程标识： 唯一地标识进程的名称或代码
· 进程状态： 标识进程是运行态、就绪态或阻塞态
· 进程实体： 指示进程的程序部分和数据部分在存储器中的位置和大小
· 调度信息（优先数）： 确定就绪进程转为运行进程的优先级
· 资源信息： 描述内存占用、外设占用等信息
· 现场信息： 包括程序计数器、程序状态字、累加器、变址寄存器的当前值
· 进程通信信息：用于进程间的通信
（5） 进程的特征
动态性：指每个进程都有一个“ 创建→执行→撤消”的生存期，在执行期间会经历一个 “等待→就绪→运行” 的状态变化，是动态地产生和消亡的。
并发性：指系统中可以同时存在多个进程，这些进程可以并地运行，在时间上可以部分地重叠。
异步性：指各个进程在逻辑上是独立的，它们在运行过程中按照各自的、不可预知的速度向前推进。
制约性：指各进程之间可以直接或间接地相互制约。
（6） 进程控制： 指操作系统对全部进程实施有效的管理，进行进程的创建、撤消及更换实体等工作。进程控制是通过原语（primitive）实现的。
（7） 原语： 是由若干条机器指令构成的、完成某一特定功能的程序段，该程序段的执行是不可中断的。常用的进程控制原语主要有以下几种：
创建原语：即根据进程调用者提供的有关程序和数据建立该进程的PCB。
撤消原语：当一个进程完成其任务后，撤消该进程的PCB，同时释放它所占用的所有资源。
阻塞原语：当某进程在运行过程中需要等待某个事件发生时，则由该进程调用阻塞原语把进程从运行状态转为阻塞状态，以便释放它所占用的处理机。
唤醒原语：一个因等待某个事件而处于阻塞态的进程，一旦等待的事件已经发生，就要用唤醒原语将其转为就绪态，以等待分配处理机。
常用的进程控制原语还有：调度进程运行原语、挂起进程原语、解除进程挂起原语、改变进程优先数原语等。
（8） 进程调度算法：是处理器的分配策略，常用的有： 先进先出法（First In First Out）、优先数法（Priority）、轮转调度（Round Robin）、分级调度。
（9） 进程通信： 即在进程之间交换信息，使整个系统有秩序地运行。
1） 低级进程通信：即信号量的P-V操作。信号量是用来表示系统资源物理实体的一种特殊变量，通常用S（整型数）表示；操作系统利用信号量的状态来对进程和资源进行管理。
P操作 P（S）
V操作 V（S）
一般代表当前进程申请某种资源
一般代表当前进程释放所占用的资源
S：=S-1，即每执行一次P操作，S被减1
S：=S+1，即每执行一次V操作，S被加1
若 S≥0该进程继续执行，否则置该进程为“阻塞”状态，并使其在S信号量的队列中等待，直到其它进程在S上执行V操作释放它为止。
若 S> 0该进程继续执行，否则释放S信号量队列中第一个等待者,改变其“阻塞”状态。
2） 高级进程通信：包括消息缓冲通信、管道通信和信箱通信。
2． 作业管理
（1） 基本概念
作 业： 指用户要求计算机进行计算或处理的一个相对独立的任务。
作业步： 指对一个作业进行顺序处理的工作步骤。
作业的状态:
提交状态 用户准备好作业程序、相关数据和作业说明书并提交给系统
后备状态 等待运行的作业在等待进入内存和分配处理机的状态
运行状态 系统挑选若干作业送入内存并按一定策略使其在处理机上运行
完成状态 作业运行结束，系统收回被占资源，并使其退出系统
‘贰’ vc++一个进程负责写入共享区,然后多个进程读取,会有什么异常吗
WinSock(Windows Sockets)是处理网络通信的Windows API。许多函数与在BSD中使用的Berkely套接字函数是相同的。套接字，简单的说就是通信双方的一种约定，用套接字中的相关函数来完成通信过程。
应用层通过传输层进行数据通信时，TCP和UDP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP/IP协议交互提供了称为套接字(Socket)的接口。
Socket可以看成在两个程序进行通讯连接中的一个端点（endpoint），一个程序将一段信息写入Socket中，该Socket将这段信息发送给另外一个Socket中，使这段信息能传送到其他程序中。一般一个server服务器对应很多客户端client连接，服务器必须维护一张客户连接列表，每增加一个客户端连接服务器端都要新建一个套接字负责与新增客户端进行对话通信。
传输套接字主要有两类：流式套接字（SOCK_STREAM）和数据报套接字（SOCK_DGRAM）。流类型的套接字是为需要可靠连接的应用程序设计的。这些程序通常使用连续的数据流。用于这种类型套接字的协议是TCP，适合FTP这类实现。流套接字是最常用的，一些众所周知的协议如HTTP、TCP、SMTP、POP3等都是基于面向流的协议。
数据报套接字使用UDP做为下层协议，是无连接的，有一个最大缓冲区大小（数据包大小的最大值）。它是为那些需要发送小数据包，并且对可靠性要求不高的应用程序设计的。与流式套接字不同，数据报套接字并不保证数据会到达终端，也不保证它是以正确的顺序到来的。数据报套接字的传输效率相当高，它经常用于音频或视频应用程序。对这些程序来说，速度比可靠性更加重要。
一个连接由（server_ip, server_port）和（client_ip, client_port）唯一确定。你可以调用getsockname()函数获取与某个套接字关联的本地地址，调用getpeername()函数获取与某个套接字关联的目的地址。
套接字有阻塞（锁定）和非阻塞（非锁定）两种模式。非阻塞和阻塞描述的是WinSock API调用行为特性。
在一个阻塞套接字上调用任何WinSock API函数（accept()/recv()/send()），都会耗费或长或短的时间“等待”返回，这会阻塞调用线程。直到有点数据可读或可写时，这种调用才返回。
阻塞模式的优点是符合时序，容易入手。缺点也是显而易见的，假设这样一种情景，一个线程中要处理多个客户（套接字A、B），我们在套接字A、B上顺序调用recv企图依次接收数据。若客户A始终不发数据，则recv(A)函数将可能永远无法返回，在这期间我们错失了客户B发送来的数据。
大多数WinSock应用都遵循“生产者－消费者”模型，应用程序需要读取（或写入）指定数量的字节，然后再对读取的数据执行一些计算。在应用程序中，可以为每个套接字都创建一个负责读取网络数据的读线程（ReadThread），以及一个负责对数据执行计算的数据处理线程（ProcessThread）。尽管这会增大一些开销，但的确是一种可行的方案。缺点便是扩展性极差，而且无法应对大规模的通信情况。
将一个套接字置为非阻塞模式之后，WinSock API调用会立即返回。大多数情况下，这些调用都会“失败”（SOCKET_ERROR），并返回一个WSAEWOULDBLOCK错误。它意味着请求的操作在调用期间没有时间完成。举个例子来说，假如在系统的输入缓冲区中，尚不存在“待决”的数据，那么recv()调用就会返回WSAEWOULDBLOCK错误。通常，我们需要重复调用同一个函数（轮询），直至获得一个成功返回代码。
假如需要编写更多的代码，以便在每个 Winsock调用中，对收到一个WSAEWOULDBLOCK错误的可能性加以应付，那么非阻塞套接字便显得有些难于操作。在这些情况下，可考虑使用“套接字I/O模型”，它管理I/O完成通知，帮助应用程序判断套接字何时可供读写。
套接字模式讨论的是套接字函数的调用特性，而I/O模型讨论的是调用背后的行为特性。
当CPU执行代码（当前活动线程）时遇上一个I/O请求（例如调用ReadFile()/WriteFile()或recv()/send()）时，系统产生一个中断，当前活动线程阻塞在此，让CPU去完成这个I/O请求，等到完成后，系统再次产生一个中断让原先的程序继续运行。也就说通过中断保持这两者间的同步，可以将中断理解为硬件化的信号量。
这就是所谓的同步I/O，一个线程中只可能同时处理一个I/O请求。因为一个I/O操作是非常耗时的，所以代码挂起后等待I/O完成的这段时间内，这个线程浪费了很多个指令周期。如果要同时反复读写大文件，则同步I/O的效率是很低的。
当然，可以考虑使用多线程来处理。例如在设计服务器时可以使用多线程来处理客户请求，每有一个客户连接请求，就创建一个新线程，专门处理它的通信请求。对于小型服务器来说，这不是问题。对于同时处理成千上万个请求的大型服务器而言，使用多线程是无效的，因为系统能够支持的线程数量毕竟是有限制的。另外一种解决方案就是使用共享负载的线程池，这涉及到异步I/O。
‘叁’ java 多线程按指定顺序轮流执行！！
个人分析：
难点1：如何保证线程按ABCD这样的顺序启动
难点2：如何保证线程一直按ABCD这样的顺序执行
做了一个简单的程序，执行结果是可以的，但是这样的缺点是完全没有发挥多线程的优势，程序代码如下，也请高手指点指点。
//用于产生从1到100的数
package org.ghand.thread.tfive;
public class Sequence {
private int num=1;
public int getNext(){
return num++;
}
}
//线程定义
package org.ghand.thread.tfive;
public class SequenceThread extends Thread {
private Sequence sequence;
private int order;
private SequenceThread next;
public boolean started=false;
public SequenceThread(String name,int or,Sequence se){
this.setName(name);
this.sequence=se;
this.order=or;
}
public void setNext(SequenceThread next){
this.next=next;
}
public void run(){
int num=sequence.getNext();
this.started=true;
while(num<101){
if(num%4==order){
System.out.println(getName()+":"+num);
if(this.next.started){
synchronized (this.next) {
this.next.notify();
}}else{
this.next.start();
}
try {
synchronized (this) {
this.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
num=sequence.getNext();
}
//
}
System.exit(0);
}
}
//测试主函数
package org.ghand.thread.tfive;
public class TestSequence {
/**
* @param args
*/
public static void main(String[] args) {
Sequence sequ=new Sequence();
SequenceThread a=new SequenceThread("A",1,sequ);
SequenceThread b=new SequenceThread("B",2,sequ);
SequenceThread c=new SequenceThread("C",3,sequ);
SequenceThread d=new SequenceThread("D",0,sequ);
a.setNext(b);
b.setNext(c);
c.setNext(d);
d.setNext(a);
a.start();
}
}
QQ：20196550 多交流
‘肆’ 在分时/多任务系统里,如果两个进程同时访问同一个文件
线程和进程都是现在电脑概念里比较时髦的用语，什么是多线程，什么是多进程?本文详细的给您介绍一下，希望能增进您对当代电脑技术的了解，有不到之处，还往高手予以更正。进程(英语：Process，中国大陆译作进程，台湾译作行程)是计算机中已运行程序的实体。进程本身不会运行，是线程的容器。程序本身只是指令的集合，进程才是程序(那些指令)的真正运行。若干进程有可能与同一个程序相关系，且每个进程皆可以同步(循序)或不同步(平行)的方式独立运行。进程为现今分时系统的基本运作单位 线程(英语：thread，台湾译为运行绪)，操作系统技术中的术语，是操作系统能够进行运算调度的最小单位。它被包涵在进程之中，一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程(lightweight processes)，但轻量进程更多指内核线程(kernel thread)，而把用户线程(user thread)称为线程。 线程是独立调度和分派的基本单位。线程可以操作系统内核调度的内核线程，如Win32 线程;由用户进程自行调度的用户线程，如Linux Portable Thread; 或者由内核与用户进程，如Windows 7的线程，进行混合调度。 同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境(register context)，自己的线程本地存储(thread-local storage)。 一个进程可以有很多线程，每条线程并行执行不同的任务。 在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责IO处理、人机交互而常备阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率 进程是资源分配的最小单位，线程是CPU调度的最小单位。线程和进程的区别在于,子进程和父进程有不同的代码和数据空间,而多个线程则共享数据空间,每个线程有自己的执行堆栈和程序计数器为其执行上下文.多线程主要是为了节约CPU时间,发挥利用,根据具体情况而定. 线程的运行中需要使用计算机的内存资源和CPU。 多进程： 进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然，程序是死的(静态的)，进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程，它们就是处于运行状态下的操作系统本身;所有由用户启动的进程都是用户进程。进程是操作系统进行资源分配的单位。 进程又被细化为线程，也就是一个进程下有多个能独立运行的更小的单位。在同一个时间里，同一个计算机系统中如果允许两个或两个以上的进程处于运行状态，这便是多任务。现代的操作系统几乎都是多任务操作系统，能够同时管理多个进程的运行。 多任务带来的好处是明显的，比如你可以边听mp3边上网，与此同时甚至可以将下载的文档打印出来，而这些任务之间丝毫不会相互干扰。那么这里就涉及到并行的问题，俗话说，一心不能二用，这对计算机也一样，原则上一个CPU只能分配给一个进程，以便运行这个进程。我们通常使用的计算机中只有一个CPU，也就是说只有一颗心，要让它一心多用，同时运行多个进程，就必须使用并发技术。实现并发技术相当复杂，最容易理解的是“时间片轮转进程调度算法”，它的思想简单介绍如下：在操作系统的管理下，所有正在运行的进程轮流使用CPU，每个进程允许占用CPU的时间非常短(比如10毫秒)，这样用户根本感觉不出来 CPU是在轮流为多个进程服务，就好象所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。 如果一台计算机有多个CPU，情况就不同了，如果进程数小于CPU数，则不同的进程可以分配给不同的CPU来运行，这样，多个进程就是真正同时运行的，这便是并行。但如果进程数大于CPU数，则仍然需要使用并发技术。 进行CPU分配是以线程为单位的，一个进程可能由多个线程组成，这时情况更加复杂，但简单地说，有如下关系： 总线程数<= CPU数量：并行运行 总线程数> CPU数量：并发运行 并行运行的效率显然高于并发运行，所以在多CPU的计算机中，多任务的效率比较高。但是，如果在多CPU计算机中只运行一个进程(线程)，就不能发挥多CPU的优势。 这里涉及到多任务操作系统的问题，多任务操作系统(如Windows)的基本原理是:操作系统将CPU的时间片分配给多个线程,每个线程在操作系统指定的时间片内完成(注意,这里的多个线程是分属于不同进程的).操作系统不断的从一个线程的执行切换到另一个线程的执行,如此往复,宏观上看来,就好像是多个线程在一起执行.由于这多个线程分属于不同的进程,因此在我们看来,就好像是多个进程在同时执行,这样就实现了多任务 多线程：在计算机编程中，一个基本的概念就是同时对多个任务加以控制。许多程序设计问题都要求程序能够停下手头的工作，改为处理其他一些问题，再返回主进程。可以通过多种途径达到这个目的。最开始的时候，那些掌握机器低级语言的程序员编写一些“中断服务例程”，主进程的暂停是通过硬件级的中断实现的。尽管这是一种有用的方法，但编出的程序很难移植，由此造成了另一类的代价高昂问题。中断对那些实时性很强的任务来说是很有必要的。但对于其他许多问题，只要求将问题划分进入独立运行的程序片断中，使整个程序能更迅速地响应用户的请求。 最开始，线程只是用于分配单个处理器的处理时间的一种工具。但假如操作系统本身支持多个处理器，那么每个线程都可分配给一个不同的处理器，真正进入“并行运算”状态。从程序设计语言的角度看，多线程操作最有价值的特性之一就是程序员不必关心到底使用了多少个处理器。程序在逻辑意义上被分割为数个线程;假如机器本身安装了多个处理器，那么程序会运行得更快，毋需作出任何特殊的调校。根据前面的论述，大家可能感觉线程处理非常简单。但必须注意一个问题：共享资源!如果有多个线程同时运行，而且它们试图访问相同的资源，就会遇到一个问题。举个例子来说，两个线程不能将信息同时发送给一台打印机。为解决这个问题，对那些可共享的资源来说(比如打印机)，它们在使用期间必须进入锁定状态。所以一个线程可将资源锁定，在完成了它的任务后，再解开(释放)这个锁，使其他线程可以接着使用同样的资源。 多线程是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的。 一个采用了多线程技术的应用程序可以更好地利用系统资源。其主要优势在于充分利用了CPU的空闲时间片，可以用尽可能少的时间来对用户的要求做出响应，使得进程的整体运行效率得到较大提高，同时增强了应用程序的灵活性。更为重要的是，由于同一进程的所有线程是共享同一内存，所以不需要特殊的数据传送机制，不需要建立共享存储区或共享文件，从而使得不同任务之间的协调操作与运行、数据的交互、资源的分配等问题更加易于解决。进程间通信(IPC，Inter-Process Communication)，指至少两个进程或线程间传送数据或信号的一些技术或方法。进程是计算机系统分配资源的最小单位。每个进程都有自己的一部分独立的系统资源，彼此是隔离的。为了能使不同的进程互相访问资源并进行协调工作，才有了进程间通信。这些进程可以运行在同一计算机上或网络连接的不同计算机上。 进程间通信技术包括消息传递、同步、共享内存和远程过程调用。
‘伍’ java多线程问题：多个线程访问同一资源时如何保证线程之间访问的顺序性。
这个需要锁，当a敲完时，加一把锁，然后只能b解开，然后b敲完，加一把锁，只能a解开，这样他们就会这样执行下去，其实这个原理在socket中有用到，你可以看看
‘陆’ access数据库支持多进程访问吗
Access数据库不支持多进程访问。ACCESS是典型的单线程软件用ACCESS本身不能修改自身线程，除非使用API，但是那肯定不稳定，得不偿失。另外，所谓的ACCESS线程不过是调用MDB。不过，只要不使用独占方式打开，可以实现多个程序同时访问MDB。
Access数据库支持VB、ASP、Unity3D、Java等的访问。Access 最多支持 255 个并且用户 Access 支持的最大数据库大小为 2 GB。
‘柒’ 线程、进程在跨线程（进程）访问内存，权限有什么不同
说法一：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行
说法二：进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程，使得多线程程序的并发性高。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
说法三：多线程共存于应用程序中是现代操作系统中的基本特征和重要标志。用过UNIX操作系统的读者知道进程，在UNIX操作系统中，每个应用程序的执行都在操作系统内核中登记一个进程标志，操作系统根据分配的标志对应用程序的执行进行调度和系统资源分配，但进程和线程有什么区别呢？
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
线程的划分尺度小于进程，使得多线程程序的并发性搞。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
进程（Process）是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例，进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统对应用程序进程的控制来实现的。
C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后，提交给计算机处理器运行。这时，处在可执行状态中的应用程序称为进程。从用户角度来看，进程是应用程序的一个执行过程。从操作系统核心角度来看，进程代表的是操作系统分配的内存、CPU时间片等资源的基本单位，是为正在运行的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。多任务环境下应用程序进程的主要特点包括：
●进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间；
●进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型；
●从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进程执行的是操作系统指令。
在Unix操作系统启动过程中，系统自动创建swapper、init等系统进程，用于管理内存资源以及对用户进程进行调度等。在Unix环境下无论是由操作系统创建的进程还要由应用程序执行创建的进程，均拥有唯一的进程标识（PID）。
说法四：应用程序在执行过程中存在一个内存空间的初始入口点地址、一个程序执行过程中的代码执行序列以及用于标识进程结束的内存出口点地址，在进程执行过程中的每一时间点均有唯一的处理器指令与内存单元地址相对应。
Java语言中定义的线程（Thread）同样包括一个内存入口点地址、一个出口点地址以及能够顺序执行的代码序列。但是进程与线程的重要区别在于线程不能够单独执行，它必须运行在处于活动状态的应用程序进程中，因此可以定义线程是程序内部的具有并发性的顺序代码流。
Unix操作系统和Microsoft Windows操作系统支持多用户、多进程的并发执行，而Java语言支持应用程序进程内部的多个执行线程的并发执行。多线程的意义在于一个应用程序的多个逻辑单元可以并发地执行。但是多线程并不意味着多个用户进程在执行，操作系统也不把每个线程作为独立的进程来分配独立的系统资源。进程可以创建其子进程，子进程与父进程拥有不同的可执行代码和数据内存空间。而在用于代表应用程序的进程中多个线程共享数据内存空间，但保持每个线程拥有独立的执行堆栈和程序执行上下文（Context）。
基于上述区别，线程也可以称为轻型进程 (Light Weight Process，LWP)。不同线程间允许任务协作和数据交换，使得在计算机系统资源消耗等方面非常廉价。
线程需要操作系统的支持，不是所有类型的计算机都支持多线程应用程序。Java程序设计语言将线程支持与语言运行环境结合在一起，提供了多任务并发执行的能力。这就好比一个人在处理家务的过程中，将衣服放到洗衣机中自动洗涤后将大米放在电饭锅里，然后开始做菜。等菜做好了，饭熟了同时衣服也洗好了。
需要注意的是：在应用程序中使用多线程不会增加 CPU 的数据处理能力。只有在多CPU 的计算机或者在网络计算体系结构下，将Java程序划分为多个并发执行线程后，同时启动多个线程运行，使不同的线程运行在基于不同处理器的Java虚拟机中，才能提高应用程序的执行效率。
‘捌’ shell中多进程实现问题
您好，在bash中，使用后台任务来实现任务的“多进程化”。在不加控制的模式下，不管有多少任务，全部都后台执行。也就是说，在这种情况下，有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况：
实例一：正常情况脚本
#!/bin/bash
for ((i=0;i<5;i++));do
{
sleep 3;echo 1>>aa && echo "done!"
}
done
这种情况下，程序顺序执行，每个循环3s，共需15s左右。
实例二：“多进程”实现
#!/bin/bash
for ((i=0;i<5;i++));do
{
sleep 3;echo 1>>aa && echo "done!"
} &
done
这个实例实际上就在上面基础上多加了一个后台执行&符号，此时应该是5个循环任务并发执行，最后需要3s左右时间。
实例三：多进程”实现，和实例二一样
#!/bin/sh
for i in 3 4 5 6 7 8 9 10 h1 h2 h3 h4 h5
do
{
sleep 3;echo 1>>aa && echo $i
i=$((i+1))
}&
done
‘玖’ Java 如何同步顺序执行多个线程
这个要分段来实现， 第一步是让线程同步，第二部是让线程有顺序。
同步：我们可以用synchronized来解决。
Java线程同步原理： java会为每个object对象分配一个monitor，当某个对象的同步方法（synchronized methods ）被多个线程调用时，该对象的monitor将负责处理这些访问的并发独占要求。
当一个线程调用一个对象的同步方法时，JVM会检查该对象的monitor。如果monitor没有被占用，那么这个线程就得到了monitor的占有权，可以继续执行该对象的同步方法；如果monitor被其他线程所占用，那么该线程将被挂起，直到monitor被释放。
当线程退出同步方法调用时，该线程会释放monitor，这将允许其他等待的线程获得monitor以使对同步方法的调用执行下去。就像下面这样:
public void test() {
synchronized (this) {
//做一些事
//这里只会有一个线程来调用该方法，因为只有一个this对象作为资源分配给该线程
}
}
顺序：我们可以用List来解决，因为它是有序的。我们只需要将要执行的线程放入到List中
上代码：
/**
* 让多个线程同步顺序执行的线程管理器
* @author bianrx
* @date 2012.1.18
* SynchronizedRunMultiThread
*/
public class SyncManager {
/**
* 待执行的线程集合，注意这里必须是Runnable接口类型，下面会解释
*/
private List<Runnable> runnableList;
public SyncManager(){}
public SyncManager(List<Runnable> runnableList) {
this.runnableList = runnableList;
}
public void setRunnable(List<Runnable> runnableList) {
this.runnableList = runnableList;
}
public void run() {
//遍历代执行的线程集合
for(Runnable runnable: runnableList) {
runThread(runnable);
}
}
/**
* 按顺序同步执行多个线程
* @author bianrx
* @date 2012.1.18
* @param runnable
*/
private void runThread(Runnable runnable) {
synchronized (this) {
runnable.run();//这里需要注意的是：必须调用run方法，因为如果你调用了start方法，线程只会向JVM请求资源，但是未必就执行其中的run。
//这个方法是同步的，所以当前只有一个线程占用了this对象。
}
}
}
‘拾’ python 多进程的顺序问题
因为进程池一次只能运行4个进程，0,1,2,3是四个进程同时执行，那么4只能等待。当进程池中任意一个进程结束后，4立即执行，所以在0结束后4开始执行，接着1,2,3陆续结束，4最后结束。