进程相关(一)

一.计算机发展史

　　多道技术

　　　　1.空间上的复用：多个程序共用一套计算机硬件

　　　　2.时间上的复用

　　　　　　　切换+保存状态

　　　　　　　　1.当一个程序遇到IO操作  操作系统会剥夺该程序的CPU执行权限（提高了CPU的利用率）

　　　　　　　　2.当一个程序长时间占用CPU，操作系统也会剥夺其执行权限(降低了程序的执行效率)

二.进程的理论

程序：一堆代码      进程：正在运行的程序

1.同步异步：表示的是任务的提交方式

　　同步：任务提交之后 原地等待的任务的执行并拿到返回结果再走  期间不做任何事情(程序的表面就是卡住了)

　　异步：任务提交之后 不在原地等待，而是继续执行下一行代码（结果是要的，但是是用过其他方式获取

2.阻塞非阻塞：表示的程序的运行状态

　　阻塞：阻塞态，在等待

　　非阻塞：就绪态，运行态

强调：同步异步  阻塞非阻塞是两对概念  不能混为一谈

三.创建进程的两种方式

创建进程就是在内存中重新去开辟一块内存空间， 将允许产生的代码丢进去

一个进程对应在内存就是一块独立的内存空间

进程与进程之间数据是隔离的 无法直接交互 但是可以通过某些技术实现间接交互

第一种：

import multiprocessing  import Process
import time
def test():
    print('子进程 is running!')
    time.sleep(2)
    print('子进程 is over!')

if __name__ == '__main__':
    p = Process(target = test)
    p.start()
    print('父进程')

第二种：

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        super.__init__()
        self.name = name

    def run(self):
        print("%s is running" %self.name)
        time.sleep(3)
        print('%s is over' %self.name)

if __name__ == '__main__':
    p = MyProcess('子进程')
    p.start()
    print('主进程')

四.进程方法join

from multiprocessing import Process
import time

def test(name,i):
    print('%s is running'%name)
    time.sleep(i)
    print('%s is over'%name)

if __name__ == '__main__':
     p_list= []
    for i in range(3):
        p = Process(target = test,args =('进程%s'%i,i))
        p.start()
        p_list.append(p)
   for p in p_list:
        p.join() #主进程代码等待子进程运行结束 才继续运行
        #主进程代码等待子进程运行结束
    print('主进程')

五.进程间数据是隔离的

一个进程对应在内存就是一块独立的内存空间

进程与进程之间数据是隔离的 无法直接交互

from multiprocessing import Process
import time

money = 100

def test():
    global money
    money = 9999

if __name__ =='__main__':
    p = Process(target = test)
    p.start()
    p.join()
    print(money)  #结果还是100  进程与进程之间数据隔离的 都是各自的独立内存空间

六.进程对象及其他方法

from multiprocessing import Process,current_process
import os
import time

def test():
    print('子进程')
    print(current_process().pid)
    print(os.getpid())   #两个都是一个意思  查询当前进程的 id
    print(os.getppid()) #获取父进程的id
    time.sleep(3)
    print('子进程 is over')

if __name__ == '__main__':
    p = Process(target = test)
    p.start()
    p.terminate()  #杀死当前进程  其实就是告诉操作系统 帮你杀死一个进程
    time.sleep(0.1)
    print(p.is_alive()) #判断进程是否活着   结果 False
    print(os.getpid())
    print(os.getppid()) #主进程的父进程就是执行它的程序进程id 例如parcharm

七.僵尸进程 与孤儿进程

1.僵尸进程

结束的进程就是僵尸进程，所有的进程都会步入僵尸进程

僵尸进程 虽然结束了 但是他有id号等需要回收 这回收的工作需要交给它的父进程来做

父进程回收子进程资源的两种方式:

　　1.join方法

　　2.父进程正常死亡

2.孤儿进程

　　子进程没死，而父进程意外死亡

　　针对linux会有儿童福利院(init)来收养父进程意外死亡他所创建的子进程

八.守护进程

from multiprocessing import Process
import time

def test(name)
    print('%s总管正常活着'%name)
    time.sleep(3)
    print('%s总管正常死亡'%name)

if __name__ == '__main__':
    p = Process(target = test,args = ('egon',))
    p.daemon = True  #将该进程设置为守护进程，这一句话必须要放在start前面，否则将会报错
    time.sleep(0.1)
    print('皇帝驾崩')

九.互斥锁

用抢票来举例子，如果多个人同时抢一张票的话，肯定是要看手速和网速。那么如果多个进程同时去操作抢票的话，怎么能够将他们区分先后顺序呢。这里用到了互斥锁。

当多个进程操作同一份数据的时候 会造成数据的错乱

这个时候必须加锁处理  将并发变为串行

　　虽然降低了效率 但是提高了数据的安全

　　注意：

　　　　1.锁不要轻易使用 容易造成死锁现象

　　　　2.只在处理数据的部分加锁，不要在全局加锁

　　锁必须在主进程中产生 交给子进程去使用

from multiprocessing import Process,Lock
import time
imort json

#查票
def search(i):
    with open ('data','r',encoding = 'utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    print('用户%s查询余票为%s' %(i,t_d.get('ticket')))

#买票
def buy(i):
    with open ('data','r',encoding = 'utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    time.sleep(1)
    if t_d.get('ticket')>0:
        t_d['ticket'] -= 1
        with open('data','w',encoding='utf-8') as f:
            json.dump(t_d,f)
        print('用户%s抢票成功'%i)
    else:
        print('没票了')


def run(i,mutex):
    search(i)
    mutex.acquire()  # 抢锁  只要有人抢到了锁 其他人必须等待该人释放锁
    buy(i)
    mutex.release()  # 释放锁


if __name__ == '__main__':
    mutex = Lock()  # 生成了一把锁
    for i in range(10):
        p = Process(target=run,args=(i,mutex))
        p.start()

操作的data

{“ticket”:1}