并发编程

什么是并发编程

并发指的是多个任务同时被执行，并发编程指的是编写支持多任务的应用程序

并发编程中重要的概念*******

1串行：自上而下顺序执行

2并发：多个任务同时执行，但是本质上是在不同进程间切换执行，由于速度快所以感觉是同时进行的

3并行：是真正的同时进行，必须具备的是多核CPU，有几个核心就能并行几个任务，当任务数量超过核心数，任务进行并发

遇到的状态：

阻塞和非阻塞可以用来描述执行任务的方式

1阻塞：程序遇到了IO操作，无法继续执行代码一种

input（）默认是一个阻塞操作

2非阻塞：程序没有遇到IO操作的一种

我们可以用一些手段将阻塞的操作变成非阻塞的操作，非阻塞的socket

一个进程的三种状态：1阻塞，2运行，3就绪

并发和串行

目前程序存在的问题

默认执行方式是串行，所谓串行，即程序自上而下运行，一行行代码执行，必须把当前任务执行完才进行下面的任务，不管花多长时间

e.g.

在tcp服务器中，如果正在进行通讯循环无法处理其他客户的要求
在硬盘中读取大文件
执行input

学习并发的目的

编写可以同时执行多个任务的程序，来提高效率

串行和并发都是程序处理任务的方式

多道技术是

实现原理：---------------------有了多道技术，计算机就可以同时并发处理多个任务

1，空间复用：

同一时间，加载多个任务到内存中，多个进程之间内存区域需要相互隔离，这个隔离是物理层面的隔离，目的是保证数据的安全

2，时间的复用：

操作系统会在多个进程之间按做切换执行，切换任务的两个情况

1当一个进程遇到了IO操作，会自动切换
2当一个任务执行时间超过阈值会强制i切换

在切换前必须保存状态，以便恢复执行----频繁切换是需要消耗资源的

当所有任务都没有io操作时，切换执行效率反而降低，为了保证并发执行，必须牺牲效率

进程

什么是进程

1，进程指的是正在运行的程序，是一系列过程的统称，也是操作系统在调度和进行资源分配的基本单位

2，进程怎么来的：当程序从硬盘读入内存，进程就产生了

3，多进程的概念:多个程序同一时间被装入内存并且执行（一个程序可以产生多个进程，比如说运行多个qq程序）

进程是实现并发的一种方式-------涉及到操作系统，因为这个概念来自于操作系统，没有操作系统就没有进程

多进程实现原理就是操作系统调度进程的原理

进程的创建和销毁

创建：

用户的交互式请求，鼠标双击
由一个正在运行的程序，调用了开启进程的接口，例如 subprosess
一个批作业的开始
系统的初始化

销毁：

任务完成，自愿退出
强制退出，taskkill kill（非自愿）
程序遇到了异常
严重的的错误，访问了不该访问的内存

PID和PPIFD

PID是当前进程的编号

PPID是父进程的编号

在运行py文件时其实是运行的python解释器

访问PID  PPID
import os
os.getpid()
os.getppid()

python如何使用多进程

创建子进程的方式

1导入multiprocessing 中的Process类实例化这个类，指定要执行的任务target

import os
from multiprocessing import Process
"""process 就表示进程"""
def task():
    print("this is sub process")
    print("sub process id %s"% os.getpid())
if __name__=='__main__'
	"开启进程的代码必须是放在__main__判断下面"
    #实例化一个进程对象，并制定他要做的事情，函数来指定
    p=Process(target =task)
    p.start()     #给操作系统发送信息，让其开启进程
    print("this is parent process")
    print('parent process is %s'% os.getpid())
    print('over')

widows 回到如父进程的代码，从头执行一遍，来获取需要处理的任务

所以在编写代码时如果是windows一定要开启进程的代码放在main判断中

linux可以不放

2导入multiprocessing中的Process类，覆盖run的方法，将要执行的任务放在run中，开启进程时会自动执行该函数

from multiprocessing import Process
import os
class Downloader(Process)
	#def__init__(self,url,size,name):
    #	super().__init__()
    #	self.url =url
    #	self.size =size
    #	self.name=name
    
    def run(self):
        print(os.getpid())
        pass
    
if __name__=='__main__'
	m=Downloader()
    m.start()
    print("parent over",os.getpid())

3进程之间内存相互隔离

from multiprocessing import Process
import os,time
a=257

def task():
    global a
    #print("2",a,id（a))
    a=200
    
if __name__=='__main__'
	p=Process(target=task)
    p.start()  #像操作系统发送指令
    
    time.sleep(4)
    print(a)

4join函数

from multiprocessing import Process
import time
def task1(name):
    for i in range(1000):
        print("%s run"% name)
def task2(name):
    for i in range(100):
        print("%s run"% name)
        
if __name__=='__main__':   #args 是给子进程传参的参数，必须是元组
    p1=Process(target=task1,arg=("p1",))
    p1.start()  #向操作系统发送指令
    #p1.join()  #让主进程 等待子进程执行完毕再急促执行
    
    p2 =Process(target=task2,args("p2",0))
    p2.start()
    
    
    p2.join()
    p1.join()
    
    #需要达到的效果是 必须保证两个子进程是并发执行的，并且over一定是在所有执行完毕后才执行的
    print('over')

案例：join的使用

#join使用
from multiprocessing import Process
import time
def task1(name):
    for i in range(10):
        print("% run "% name)
        
if __name__=='__main__':  #args 是给子进程传递额参数，必须是元组
    ps =[]
    for i  in range(10):
        p=Process(target=task1,arg=(i,))
        p.start()
        ps.append(p)
        
    #换个join下
    for i in ps:
        i.join()
        
    print('over')

进程对象的常用属性：

if__name__=='__main__':
    p=Process(target=task,name="老司机进程")
    p.start()
    p.join()
    print(p.name)
    p.daemon  #守护进程
    print(p.exitcode)  #获取进程的退出码   就是exit()函数中传入的值
    print(p.is_alive())#查看进程是否存活
    print('zi',p.pid)  #获取进程id
    print(os.getpid())
    p.terminate()      #终止进程  与strat 相同的是，不会立即终止，因为操作系统有很多事要做

僵尸进程和孤儿进程

孤儿进程：当父进程已经结束了，而子进程还在运行，子进程就变成了孤儿进程，尤其是存在的重要性，没有不良影响

僵尸进程：当一个进程结束了，它任然还有一些数据存在，此时称之为

在linux机制中，有这么一个机制，父进程无论什么时候都可以获取到子进程的一些数据

子进程任务完成后，确实结束了但是任然保留一些数据，目的是为了让父进程能够获取这些信息

linux中，可以调用waitpid来彻底清除子进程的残留信息

python中，已经封装处理了僵尸进程操作，无需关心