多道技术:

"""
在学习并发编程的过程中 不做刻意提醒的情况下 默认一台计算机就一个CPU(只有一个干活的人)
"""
单道技术
所有的程序排队执行 过程中不能重合
多道技术
利用空闲时间提前准备其他数据 最大化提升CPU利用率 多道技术详细
1.切换
计算机的CPU在两种情况下会切换(不让你用 给别人用)
1.程序有IO操作
输入\输出操作
input、time.sleep、read、write
2.程序长时间占用CPU
我们得雨露均沾 让多个程序都能被CPU运行一下 2.保存状态
CPU每次切换走之前都需要保存当前操作的状态 下次切换回来基于上次的进度继续执行 """
开了一家饭店 只有一个服务员 但是同时来了五桌客人
请问:如何让五桌客人都感觉到服务员在服务他们
让服务员化身为闪电侠 只要客人有停顿 就立刻切换到其他桌 如此往复
"""

进程与程序的区别:

    程序:一堆死代码(还没有被运行起来)
    进程:正在运行的程序(被运行起来了)


进程的调度算法(重要):


   
1.FCFS(先来先服务)
      对短作业不友好


 
  2.短作业优先调度
      对长作业不友好


    3.时间片轮转法+多级反馈队列(目前还在用)
      将时间均分 然后根据进程时间长短再分多个等级
      等级越靠下表示耗时越长 每次分到的时间越多 但是优先级越低


进程的并行与并发:

并行:-->  多个进程同时执行   必须有多个cpu参与,单个cpu无法实现并行

并发:-->  多个进程看上去像同时执行   单个cpu可以实现,多个cpu肯定也可以

)并行可以称作并发,但是并发不能称作并行


进程三状态:

非阻塞态:

就绪态:所有的进程在被CPU执行之前都必须先进入就绪态等待
运行态:CPU正在执行

阻塞态:

阻塞态:进程运行过程中出现了IO操作 阻塞态无法直接进入运行态 需要先进入就绪态

Process:

异步:不等任务执行完,直接执行下一个任务。(同步:一定要等任务执行完了,得到结果,才执行下一个任务。)

因为运行函数需要时间,所以先执行子进程下面的任务

同一台计算机上的多个进程数据是严格意义上的物理隔离(默认情况下)

第一种方法:

from multiprocessing import Process
import time money = 1000
def task(name,age):
print('hello world',name)
global money
money = 666
time.sleep(3)
print('go die',age) if __name__ == '__main__':
p1 = Process(target = task,args=('egon',123)) #args后面是元组
p1.start() #创建子进程 会新生成一个内存空间
print(money) #主进程代码打印money 1000
#打印
#1000
#hello world egon
#go die 123

第二种方法:

from multiprocessing import Process
import time class A(Process):
def __init__(self,name,age):
super().__init__() #继承父类的属性
self.name = name
self.age = age def run(self):
print('hello world',self.name,self.age)
time.sleep(3)
print('go die',self.age,self.name) if __name__ == '__main__':
obj = A('json',123) #创建一个obj对象
obj.start() #创建子进程
print('stop')
#打印
#stop
#hello world json 123
#go die 123 json

进程的join方法:

from multiprocessing import Process
import time def task(name, n):
print('%s is running' % name)
time.sleep(n)
print('%s is over' % name) if __name__ == '__main__':
p1 = Process(target=task, args=('jason1', 1))
p2 = Process(target=task, args=('jason2', 2))
p3 = Process(target=task, args=('jason3', 3))
# p.start() # 异步
'''主进程代码等待子进程代码运行结束再执行'''
start_time = time.time()
p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
print(time.time() - start_time) # 6秒多 p1.start()
p2.start()
p3.start()
p1.join()
p2.join() #3个子线程同时运行
p3.join()
print(time.time() - start_time) # 3秒多

 IPC机制:

IPC:进程间通信
消息队列:存储数据的地方 所有人都可以存 也都可以取

from multiprocessing import Queue

q = Queue(3)  # 括号内可以指定存储数据的个数
# 往消息队列中存放数据
q.put(111)
# print(q.full()) # 判断队列是否已满
q.put(222)
q.put(333)
# print(q.full()) # 判断队列是否已满
# 从消息队列中取出数据
print(q.get())
print(q.get())
# print(q.empty()) # 判断队列是否为空
print(q.get())
# print(q.empty()) # 判断队列是否为空
# print(q.get())
print(q.get_nowait()) """
full() empty() 在多进程中都不能使用!!!
"""
from multiprocessing import Queue
def product(q):
q.put('子进程p添加的数据') def consumer(q):
print('子进程获取队列中的数据', q.get()) if __name__ == '__main__':
q = Queue()
# 主进程往队列中添加数据
# q.put('我是主进程添加的数据')
p1 = Process(target=consumer, args=(q,))
p2 = Process(target=product, args=(q,))
p1.start()
p2.start()
print('主')
#打印:
#主
#子进程获取队列中的数据 子进程p添加的数据

生产者消费者模型:

"""回想爬虫"""
生产者
负责产生数据的'人'
消费者
负责处理数据的'人' 该模型除了有生产者和消费者之外还必须有消息队列(只要是能够提供数据保存服务和提取服务的理论上都可以)

进程对象的多种方法:

1.如何查看进程号
from multiprocessing import Process, current_process
current_process()
current_process().pid
import os
os.getpid()
os.getppid()
2.终止进程
p1.terminate()
ps:计算机操作系统都有对应的命令可以直接杀死进程
3.判断进程是否存活
p1.is_alive()
4.start()
5.join()

守护进程:

守护进程会随着守护的进程结束而立刻结束
    eg: 吴勇是张红的守护进程 一旦张红嗝屁了 吴勇立刻嗝屁

from multiprocessing import Process
import time def task(name):
print('德邦总管:%s' % name)
time.sleep(3)
print('德邦总管:%s' % name) if __name__ == '__main__':
p1 = Process(target=task, args=('大张红',))
p1.daemon = True
p1.start()
time.sleep(1)
print('恕瑞玛皇帝:小吴勇嗝屁了')

僵尸进程与孤儿进程:

'''
僵尸进程
进程执行完毕后并不会立刻销毁所有的数据 会有一些信息短暂保留下来
比如进程号、进程执行时间、进程消耗功率等给父进程查看
ps:所有的进程都会变成僵尸进程
孤儿进程
子进程正常运行 父进程意外死亡 操作系统针对孤儿进程会派遣福利院管理 '''

多进程数据错乱问题:

"""
多进程操作数据很可能会造成数据错乱>>>:互斥锁
互斥锁
将并发变成串行 牺牲了效率但是保障了数据的安全
"""

进程,Process模块,join方法,ipc机制,守护进程的更多相关文章

  1. 多进程TCP服务端并发- 进程join方法 - IPC机制

    目录 同步与异步 阻塞与非阻塞 综合使用 创建进程的多种方式 进程间数据隔离 进程join方法 IPC机制 生产者消费者模型 进程对象的多种方法 僵尸进程与孤儿进程 守护进程 多线程实现TCP服务端并 ...

  2. 同步异步、mutiprocessing创建进程process模块及进程对象的多种方法、消息队列Queue

    目录 同步异步 阻塞与非阻塞 综合使用 创建进程的多种方式之multiprocess.process模块 进程间数据隔离 进程的join方法 IPC机制 生产者 消费者模型 进程对象的多种方法 守护进 ...

  3. python并发编程02 /多进程、进程的创建、进程PID、join方法、进程对象属性、守护进程

    python并发编程02 /多进程.进程的创建.进程PID.join方法.进程对象属性.守护进程 目录 python并发编程02 /多进程.进程的创建.进程PID.join方法.进程对象属性.守护进程 ...

  4. 进程Process之join、daemon(守护)、terminate(关闭)、multiprocessing之锁、信号量和事件

    一.Process 参数介绍: 1 group参数未使用,值始终为None 2 target表示调用对象,即子进程要执行的任务 3 args表示调用对象的位置参数元组,args=(1,2,'a',) ...

  5. 进程Process之join、daemon(守护)、terminate(关闭)

    一.Process 参数介绍: 1 group参数未使用,值始终为None 2 target表示调用对象,即子进程要执行的任务 3 args表示调用对象的位置参数元组,args=(1,2,'a',) ...

  6. Process 开启子进程 的两种方式、join控制子进程、守护进程

    一.join控制子进程的一种方式 当主进程需要在子进程结束之后结束时,我们需要用到join来控制子进程. import time import random from multiprocessing ...

  7. 第三十天- 进程 Process模块 空间隔离

    1.进程: 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础.在早期面向进程设计的计算机结构中,进程是程序的基本执行实体: ...

  8. 并发编程 process 模块的方法及运用 僵尸与孤儿

    进程创建的两种方法 Process() 继承Process 重写run方法,传参数的时候要写init,但是注意要在init方法中运行父类的init方法 Windows下写代码开启子进程时,必须写上if ...

  9. Python 35 进程间的通信(IPC机制)、生产者消费者模型

    一:进程间的通信(IPC):先进先出  管道:队列=管道+锁 from multiprocessing import Queue q=Queue(4) q.put(['first',],block=T ...

  10. Linux 基于IPC机制实现进程间的共享内存处理

    今天学习了相关于IPC(InterProcess Communication ,进程间通信)的相关知识.就做个笔记,一来让大家检查一下我的理解方面是不是有错误,二来也为了能让更多的博友们了解到相关的知 ...

随机推荐

  1. systick 理解

    systick 中断的优先级往往设置为最低值,而不是最高值:如果设置为最低值不会发生上图标号[6]处的情况,设置为最低可能会被其他中断抢占,延长systick的响应时间,但是这个延迟不会累计,因为sy ...

  2. MD5加密汇总

    1 #region MD5 2 /// <summary> 3 /// 16位MD5加密 4 /// </summary> 5 /// <param name=" ...

  3. HOOK大法

    // 请求头hook 测试网站同花顺 OK var header_old = window.XMLHttpRequest.prototype.setRequestHeader;window.XMLHt ...

  4. STL妙用总结(持续更新)

    1.  map 自带排序功能.从小到大!把一堆东西按照要排序的键放在map里可以当二叉排序树使用.插入和检索都不错

  5. pip install keras==2.0.3 -i https://pypi.tuna.tsinghua.edu.cn/simple

    pip install keras==2.0.3 -i https://pypi.tuna.tsinghua.edu.cn/simple

  6. hhtp协议和html标签分类css

    HTTP协议四大特性: 1基于请求响应 2 基于tcp/ip协议之上的应用层协议 3 无状态 不能保存用户信息 4 无链接,短链接 二 get和post的区别? 1 get 不安全,get请求没有请求 ...

  7. 6-SSRF漏洞

    1.SSRF漏洞介绍 SSRF是一种由攻击者构造请求,由服务端发起请求的安全漏洞.一般情况下,ssrf攻击的目标是外网无法访问的内部系统. 2.SSRF原理 Ssrf的形成大多是由于服务端提供了从其他 ...

  8. ubuntu下删除U盘文件到回收站无法清空问题的解决

    Ubuntu可以自动加载U盘 每当,拷贝新的文件,而空间不足的时候,就会删除原有的文件. 可是,它不是彻底删除,而是放在垃圾箱中(/home/mrc/.local/share/Trash/files) ...

  9. Use `tensor.item()` in Python or `tensor.item<T>()` in C++ to convert a 0-dim tensor to a number

    IndexError: invalid index of a 0-dim tensor. Use `tensor.item()` in Python or `tensor.item<T>( ...

  10. 老系统的奇葩问题-tomcat7启动失败

    好多年的tomcat7系统了  当时部署安装为了服务 直接启动 就这么简单 好多年没动过了 这次修改了些东西 需要重启 却报错了... 解决: 把服务删除  使用bat启动  成功. 原因:可能是多个 ...