分时——现在流行的PC，服务器都是采用这种运行模式，即把CPU的运行分成若干时间片分别处理不同的运算请求 linux系统
实时——一般用于单片机上、PLC等，比如电梯的上下控制中，对于按键等动作要求进行实时处理 

第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。[3] 
进程是操作系统中最基本、重要的概念。是多道程序系统出现后，为了刻画系统内部出现的动态情况，描述系统内部各道程序的活动规律引进的一个概念,所有多道程序设计操作系统都建立在进程的基础上。

注意：同一个程序执行两次，就会在操作系统中出现两个进程，所以我们可以同时运行一个软件，分别做不同的事情也不会混乱。

进程调度

要想多个进程交替运行，操作系统必须对这些进程进行调度，这个调度也不是随即进行的，而是需要遵循一定的法则，由此就有了进程的调度算法。

 先来先服务调度算法

 短作业优先调度算法

 时间片轮转法

 多级反馈队列 

进程的并行与并发

　　所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

 例子

阻塞与非阻塞

      阻塞和非阻塞这两个概念与程序（线程）等待消息通知(无所谓同步或者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序（线程）等待消息通知时的状态角度来说的

1. 同步阻塞形式

　　效率最低。拿上面的例子来说，就是你专心排队，什么别的事都不做。

2. 异步阻塞形式

　　如果在银行等待办理业务的人采用的是异步的方式去等待消息被触发（通知），也就是领了一张小纸条，假如在这段时间里他不能离开银行做其它的事情，那么很显然，这个人被阻塞在了这个等待的操作上面；

　　异步操作是可以被阻塞住的，只不过它不是在处理消息时阻塞，而是在等待消息通知时被阻塞。

3. 同步非阻塞形式

　　实际上是效率低下的。

　　想象一下你一边打着电话一边还需要抬头看到底队伍排到你了没有，如果把打电话和观察排队的位置看成是程序的两个操作的话，这个程序需要在这两种不同的行为之间来回的切换，效率可想而知是低下的。

4. 异步非阻塞形式

　　效率更高，

　　因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。

　　比如说，这个人突然发觉自己烟瘾犯了，需要出去抽根烟，于是他告诉大堂经理说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操作上面，自然这个就是异步+非阻塞的方式了。

很多人会把同步和阻塞混淆，是因为很多时候同步操作会以阻塞的形式表现出来，同样的，很多人也会把异步和非阻塞混淆，因为异步操作一般都不会在真正的IO操作处被阻塞。

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍：
1 group参数未使用，值始终为None
2 target表示调用对象，即子进程要执行的任务
3 args表示调用对象的位置参数元组，args=(1,2,‘egon‘,)
4 kwargs表示调用对象的字典,kwargs={‘name‘:‘egon‘,‘age‘:18}
5 name为子进程的名称

import os
import time
from multiprocessing import Process

def func():
    for i in range(10):
        time.sleep(0.5)
        print(‘子进程%s:‘ % (i + 1), os.getpid(), os.getppid())

if __name__ == ‘__main__‘:　　# 这一句只是在windows上必须写，不然报错
    print(‘主进程：‘, os.getpid(), os.getppid())
    p = Process(target=func)
    p.start()
    for i in range(10):
        time.sleep(0.5)
        print(‘*‘ * i)
‘‘‘
主进程： 1304 5160

子进程1: 6848 1304
*
子进程2: 6848 1304
**
子进程3: 6848 1304
***
子进程4: 6848 1304
****
子进程5: 6848 1304
*****
子进程6: 6848 1304
******
子进程7: 6848 1304
*******
子进程8: 6848 1304
********
子进程9: 6848 1304
*********
子进程10: 6848 1304
‘‘‘

# 给子进程传参数

import os
import time
from multiprocessing import Process

def func(arg, n):
    for i in range(10):
        time.sleep(0.5)
        print(‘子进程%s：%s‘ % (n, arg), os.getpid(), os.getppid())

if __name__ == ‘__main__‘:
    print(‘主进程‘, os.getpid(), os.getppid())
    p = Process(target=func, args=(‘a‘, 10))    # 给子进程传参，必须是元祖类型
    p.start()
    for i in range(10):
        time.sleep(0.5)
        print(‘*‘ * i)
‘‘‘
主进程 5684 5160

子进程10：a 7804 5684
*
子进程10：a 7804 5684
**
子进程10：a 7804 5684
***
子进程10：a 7804 5684
****
子进程10：a 7804 5684
*****
子进程10：a 7804 5684
******
子进程10：a 7804 5684
*******
子进程10：a 7804 5684
********
子进程10：a 7804 5684
*********
子进程10：a 7804 5684
‘‘‘

# 进程之间数据隔离问题

import os
import time
from multiprocessing import Process

count = 100
def func():
    global count
    count -= 1
    print(‘子进程：‘, count, os.getpid(), os.getppid())

if __name__ == ‘__main__‘:
    print(‘主进程：‘, count, os.getpid(), os.getppid())
    p = Process(target=func)
    p.start()
    time.sleep(2)
    print(‘主进程：‘, count, os.getpid(), os.getppid())
‘‘‘
主进程： 100 7704 5160
子进程： 99 7476 7704

主进程： 100 7704 5160
‘‘‘

# 启动多个进程

import os
from multiprocessing import Process

def func(arg):
    print(‘子进程%s：‘ % arg, os.getpid(), os.getppid())

if __name__ == ‘__main__‘:
    for i in range(10):
        Process(target=func, args=(i,)).start()
‘‘‘
因为10个子进程启动时是异步进行的，所以顺序会乱

子进程0： 6632 6736
子进程1： 7912 6736
子进程2： 2908 6736
子进程3： 6380 6736
子进程4： 4484 6736
子进程5： 4456 6736
子进程7： 4732 6736
子进程8： 2624 6736
子进程6： 5340 6736
子进程9： 4564 6736
‘‘‘

# 子进程和父进程的关系

import os
import time
from multiprocessing import Process

def func(arg):
    print(‘子进程%s：‘ % arg, os.getpid(), os.getppid())
    time.sleep(5)
    print(‘子进程end‘)

if __name__ == ‘__main__‘:
    for i in range(10):
        Process(target=func, args=(i,)).start()
    print(‘父进程********‘)
‘‘‘
父进程********
子进程0： 5232 4356
子进程1： 4360 4356
子进程2： 7192 4356
子进程3： 6216 4356
子进程5： 3028 4356
子进程6： 6316 4356
子进程9： 3376 4356
子进程7： 896 4356
子进程8： 5668 4356
子进程4： 6068 4356
子进程end
子进程end
子进程end
子进程end
子进程end
子进程end
子进程end
子进程end
子进程end
子进程end
‘‘‘
# 1.父进程和子进程的启动时异步的
#     父进程只负责通知操作系统启动子进程
#     接下来的工作由操作系统接手 父进程继续执行
# 2.父进程执行完毕之后并不会直接结束程序，
#     而是会等待所有的子进程都执行完毕之后才结束
#     父进程要负责回收子进程的资源