进程 并发 IO操作 阻塞 同步 异步

什么是进程:

　　一个运行中的程序就是一个进程

什么是同步:

　　程序顺序执行,多个任务之间串行执行

什么是异步:

　　多个任务同时 运行

什么是阻塞:

　　input  

　　sleep

　　***recv

　　***recvfrom 

　　***accept

　　程序由于不符合某个条件或者等待某个天剑满足在某一个地方进入等待状态

什么是非阻塞:

　　sk.setblocking(False)就让这个socket模型buzuse了

 并行: 

　　微观上是指两者同时执行,比如赛跑,两个人都在不停的往前跑     

　　同一时刻不知有一个CPU在工作

并发:

　　宏观上实在同时运行的

　　微观上是一个一个顺序执行

　　同一时刻只有一个CPU在工作

io操作:

　　input 输入到内存 read load  recv accept recvfrom input

　　output 从内存输出  write  dump send  connect sendto print

multiprocessing模型

import time

from multi'processing import Process

#通过并发实一个有并发效果的socket server

开启了一个子进程就已经实现了并发:父进程(主进程)

def son_process():

　　print("son start")

　　time.sleep(1)

　　print("son end")

if __name __ =="__main__":

　　p = Process(target = son _process)#执行子进程要执行的代码

　　p.start()#通知操作系统开启一个子进程

　　for i in range(10):

　　　　print("主进程")

　　　　time.sleep(0.3)

import time

from multi'processing import Process

#2.开启多个子进程(1)

def son_process():

　　print("son start")

　　time.sleep(1)

　　print("son end")

if __name __ =="__main__":

　　p1 = Process(target = son _process)#执行子进程要执行的代码

　　p1.start()#通知操作系统开启一个子进程

　　p2 = Process(target = son _process)#执行子进程要执行的代码

　　p2.start()#通知操作系统开启一个子进程

#开启多个子进程(2)

def son_process():

　　print("son start")

　　time.sleep(1)

　　print("son end")

if __name __ =="__main__":

　　for i  inrange(3):

　　p  = Process(target = son _process)#执行子进程要执行的代码

　　p.start()#通知操作系统开启一个子进程

　　

3.可以给子进程传参数么

def son_process():

　　print("son start")

　　time.sleep(1)

　　print("son end")

if __name __ =="__main__":

　　for i  inrange(3):

　　p  = Process(target = son _process,args = (i,))#执行子进程要执行的代码

　　p.start()#通知操作系统 start并不意味着子进程已经开始了

能不能用多进程实现一个并发的socket  server

#4.主进程可不可以直接结束一个子进程

def son_process():

　　print("son start",1)

　　time.sleep(1)

　　print("son end",1)

if __name __ =="__main__":

　　for i  inrange(10):

　　　　p  = Process(target = son _process,args = (i,))#执行子进程要执行的代码

　　　　p.start()

　　print("主进程的代码执行完毕")

主进程等待子进程结束之后才结束

#5.僵尸进程

def son_process():

while True:

　　print("son start",1)

　　time.sleep(1)

　　print("son end",1)

if __name __ =="__main__":

　　　p  = Process(target = son _process,args = (1,))#执行子进程要执行的代码

　　　p.start()

　　　print("主进程的代码执行完毕")

　　　print(p.is_alive())#子进程还活着

　　　pterminate()#结束一个子进程,异步的

　　　print(p.is_alive())#子进程还在活着

　　　time.sleep(0.1)

　　　print(p.is_alive())

#5.进程之间数据隔离的概念

n =100

def sub_n():

　　global n#子进程对于主进程中的全局变量的谢盖是不该不生效的

　　n -=1

　　print("子进程n:",n)

if __name__ == "__main__":

　　p = Process(target = sub_n)

　　p.start()

　　p.join()#阻塞 直达子进程p结束　

　　peint("主进程n:",n)　

#6.开启10个继承执行subn

#主进程里的print("主进程n:",n)这句话在是个子进程执行完毕之后才执行

n =[100]

imort random

def sub_n():

　　global n#子进程对于主进程中的全局变量的谢盖是不该不生效的

　　time.sleep(random.random())

　　n.append(1)

　　print("子进程n:",n)

if __name__ == "__main__":

　　p_lst =[]

　　for i in range(10):

　　　　p = Process(target = sub_n)#

　　　　p.start()

　　　　p_lst.append(p)

　　for p in p_lst:p.jion()#阻塞只有一个条件能够让我继续执行

　　print("主进程n:",n)　

###守护进程

什么是守护进程:

监控系统

　　每隔1分钟主动汇报当前程序的状态

import time

from  multiprocessing import Process

def alive():

　　while True:

print("连接监控程序,并且发送报活信息"

　　time.sleep(0.6)

　)

def func():

　　　　"主进程中的核心代码"

　　while True:

　　　　print("选择的项目")

　　　　time.sleep(1)

　　　　n= input("请选择你要做的操作")

　　　　int(n)

　　　　print("根据用户的选择做事")

if __name__ = "__main__":

　　p =Process(target=alive).start()

　　p.daemon = True#设置子进程为守护进程,守护进程会随着主进程代码的结束而结束

　　p.start()

　　p =Process(target=func)

　　p.start()

　　p.join()#在主进程中等待

设置子进程为守护进程,守护进程会随着主进程代码的结束而结束

由于主进程要负责给所有的子进程收尸,所以主进程必须是　

主进程会等待所有的子进程结束之后才结束

守护进程在主进程的代码结束之后就结束　

process类:

　　开启一个子进程

　　能不能给子进程传递一个参数

　　能不能有一个返回值

　　主进程控制子进程的同步

　　守护进程

　　另一种开启子进程的方式

Lock 锁

　　保证数据的安全性

S