今日内容概要

• 进程对象及其他方法

• 僵尸进程与孤儿进程

• 守护进程

• 互斥锁

• 队列介绍

• 进程间通信IPC机制

• 生产者消费者模型

• 线程相关知识点

今日内容详细

"""
一台计算机上面运行着很多进程，那么计算机是如何区分并管理这些进程服务端的呢？
计算机会给每一个运行的进程分配一个PID号
"""
from multiprocessing import Process, current_process
current_process().pid  # 查看当前的进程号


import os
os.getpid()  # 查看当前进程进程号
od.getppid()  # 查看当前进程的父进程进程号


p.terminate() # 杀死当前进程
# 告诉操作系统帮你杀死当前进程 但是需要一定的时间 而代码的运行速度极快
time.sleep(0.1)
print(p.is_alive())  # 判断当前进程是否存活

僵尸进程与孤儿进程（了解）

# 僵尸进程
"""
死了但是没有死透
当你开设了子进程之后，该进程死后不会立刻释放占用的进程号
因为要让父进程能够查看到它开设的子进程的一些基本信息，占用的pid号
所有的进程都会步入僵尸进程
	父进程不死并且在无限制的创建子进程并且子进程也不结束
	父进程调用join方法
"""
# 孤儿进程
"""
子进程存货，父进程意外死亡
操作系统会开设一个专门管理孤儿进程回收相关资源
"""

守护进程

from multiprocessing import Process
import time

def task(name):
	print('%s总管正在活着'% name)
    time.sleep(3)
    print('%s总管正在死亡'% name)
    
    
if __name__ == '__main__':
    p = Process(target=task,args=('egon',))
    p.daemon = True # 将进程p设置成守护进程 一定要放在start上面才有效，否则报错
    p.start()
    print('是的肌肤健康')

互斥锁

多个进程操作同一份数据的时候，会出现数据错乱的现象

针对上述问题，解决方式就是枷锁处理：将并发变成串行，牺牲效率但是保证了数据的安全

from multiprocessing import Process,Lock
import json
import time
import random

# 查票
def search(i):
	with open('data','r',encoding='utf-8') as f:
        dic = json.load(f)
    print('用户%s查询余票：%s' %(i,dic.get('ticket_num')))
    
    
# 买票
def buy(i):
    # 先查票
    with open('data','r',encoding='utf_8')as f:
		dic= json.load(f)
    time.sleep(random.randint(1,3))
    time.sleep(random.randint(1,3))
    if dic.get('ticket_num')>0:
        dec['ticket_num'] -=1
        with open('data','w',encoding='utf-8')as f:
            json.dump(dic,f)
        print('用户%s买票成功'%i)
    else:
        print('用户%S买票失败'%i)
        
        
# 整合上面两个函数
def run(i,mutex):
    search(i)
    # 抢锁
    mutex.acquire()
    buy(i)
    # 释放锁
    mutex.release()
    
    
if __name__ == '__main__':
    # 在主进程中生成一把锁，让所有的子进程抢，谁先抢到谁先买票
    metex = Lock()
    for i in range(1,11):
        p = Process(target=run,args=(i,mutex))
        p.start()
"""
注意：
    1.锁不要轻易的使用，容易造成死锁现象
    2.锁只在处理数据的部分加来保证数据安全
"""

    

队列Queue模块

"""
队列：管道+锁
队列：先进先出

"""
from multiprocessing import Queue
# 创建一个队列
q=Queue(5) # 括号内的数字，表示生成的队列最大可以同时存放的数据量

# 往队列中存放数据
q.put(111)
...
...
q.put(555)
# 当队列数据放满了之后，如果还有数据要放程序会阻塞，直到有位置让出来，不会报错

# 往队列中去数据
v1=q.get()
...
...
v5=q.get()
q.empty() # 判断当前队列是否为空
q.full() # 判断当前队列是否满了
q.get_nowait() #没有数据直接报错
q.get(timeout=3) # 没有数据原地等待三秒之后在报错

IPC机制

from multiprocessing import Queue,Process


1.主进程跟子进程借助队列通信
def producer(q):
    q.put('代码改变世界！')
if __name__ == '__main__':
    q=Queue()
    p=Process(target=producer,args(q,))
    p.start()
    print(q.get())
2、子进程跟子进程借助于队列通信
def producer(q):
    q.put('代码改变世界')
    
def consumer(q):
    print(q.get())
    
    
if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer,args=(q,))
    p1 = Process(target=consumer,args=(q,))
    p.start()
    p1.start()

生产者消费者模型

"""
生产者：生产/制造东西
消费者：消费/处理东西
该模型除了上述两个之外话需要一个媒介
生产者+消息队列=消费者
"""
from multiprocessing import Process,Queue,JoinableQueue
import time
import rangdom

def producer(name,food,q):
    for i in range(5):
        data = '%s生产了%s%s'%(name,food,i)
        time.sleep(rangdom.randint(1,3))
        print(data)
        # 将数据放入队列中
        q.put(data)
        
def cunsumer(name,q):
    while True:
        food=q.get() # 没有数据会卡住
        time.sleep(random.randint(1,3))
        print('%s吃了%s'%(name,food))
        q.task_done() # 告诉列队已经从里面取出了一个数据并且处理完毕
                      # 每当调用task_done的时候 计数器-1
        
        
if __name__ == '__main__':
    q = JoinableQueue() # 每当往该队列中存入数据的时候，计数器+1
    p1 =Process(target=producer,args=('小王','包子',q))
    p2 =Process(target=producer,args=('小李','牛奶',q))
    c1=Process(target=consumer,args=('张三'，q))
    c2=Process(target=consumer,args=('李四'，q))
    p1.start()
    p2.start()
    # 将消费者设置成守护进程
    c1.daemon=True
    c2.daemon=True
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    q.join() # 当计数器为0的时候，才往后运行

线程理论

• 什么是线程

  """
  进程：资源单位，起一个进程仅仅只是在内存空间中开辟一块独立的空间
  线程：执行单位，真正被cpu执行的是线程，线程指的是代码的执行过程
  
  进程和线程都是虚拟单位
  """
  

• 为何要有线程

  """
  开设进程
      1、申请内存空间   耗资源
      2、"拷贝代码"   耗资源
      
  开设线程
      一个进程内可以开设多个进程，在用一个进程内开设多个线程无需再次申请内存空间操作
  
  总结：
      开设线程的开销要远远小于进程的开销
      用一个进程下的多个线程数据是共享的
     
  """
  

标签：PC机,__,队列,互斥,线程,Process,进程,import
来源： https://www.cnblogs.com/md-my/p/15379461.html