(并发编程)进程 (multiprocessing--Process实现进程并发）

['创建进程2方式种'，

'进程对象属性：join方法，守护进程obj.daemon=True,obj.pid, obj.name, obj.terminate(),obj.is_alive()等 '

'os.getpid,os.getppid',

'互斥锁(Lock())',

'僵尸进程与孤儿进程',

'内存空间物理上隔离']
并发的本质：切换+保持状态
一、同一个程序执行多次是多个进程
每一个进程有一个PID
import os
os.getppid() #父的pid (pycharm.exe)#cmd 中 pyhon 路径父的pid(cmd.exe)
os.getpid() #自己的pid (python.exe)

二、开启子进程的两种方式
windows (createprocess) 创建子进程时子辈除了拷贝父辈的信息还创建了些自己的东西
unix (fork) 创建子进程时拷贝父辈的信息，子进程的初始状态和父辈一致

第一种（比较常用）
from multiprocessing import Process
import time

def task(name):
    print('%s is running' %name)
    time.sleep(3)
    print('%s is done' %name)

if __name__ == '__main__':
    # 在windows系统之上，开启子进程的操作一定要放到这下面
    # Process(target=task,kwargs={'name':'egon'})   #两种传参方式皆可
    p=Process(target=task,args=('egon',))          #两种传参方式皆可
    p.start() # 向操作系统发送请求，操作系统会申请内存空间，把父进程的数据拷贝给子进程，作为子进程的初始状
    print('======主')

第二种
from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        super(MyProcess,self).__init__()     #Process在init里面有相应设置，要遗传下来，否则报错
        self.name=name

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

if __name__ == '__main__':
    p=MyProcess('egon')
    p.start()   #p.start()调用了类中的run（）方法（规定）
print('主')

三、进程的内存空间相互隔离
from multiprocessing import Process
import time

x=1000
def task():
    time.sleep(3)
    global x
    x=0
    print('儿子死啦',x)

#在之前最好只有函数或变量的定义，没有具体的执行（print等）
if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    time.sleep(5)
print(x)
#在子进程中对变量x的修改不影响父进程中x的值

四、父进程等待子进程结束 p1.join()

#（等待p1 卡住）等儿子死了，wait回收儿子的pid等遗留下的东西
#了解连续start再连续join 和连续start，join。。。。
from multiprocessing import Process
import time

x=1000
def task(n):
    print('%s is runing' %n)
    time.sleep(n)

if __name__ == '__main__':
    start_time=time.time()

    p1=Process(target=task,args=(1,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(3,))
    p1.start()
    p2.start()
    p3.start()

    p3.join() #3s
    p1.join()
    p2.join()

print('主',(time.time() - start_time))        #3.01637601852417

#用循环
from multiprocessing import Process
import time

x=1000

def task(n):
    print('%s is runing' %n)
    time.sleep(n)

if __name__ == '__main__':
    start_time=time.time()
    p_l=[]
    for i in range(1,4):
        p=Process(target=task,args=(i,))
        p_l.append(p)
        p.start()

    for p in p_l:
        p.join()

print('主',(time.time() - start_time))       #3.0141923427581787

五、进程对象的其他属性
from multiprocessing import Process
import time

def task(n):
    print('%s is runing' %n)
    time.sleep(n)

if __name__ == '__main__':   # 在windows系统之上，开启子进程的操作一定要放到这下面
    start_time=time.time()
    p1=Process(target=task,args=(1,),name='任务1')
p1daemon=True    #再obj发出创建前，将obj变成守护进程，主进程执行完毕后子进程跟着结束
    p1.start()         #向操作系统发创建子进程请求，父进程无需等待
    print(p1.pid)
    print(p1.name)     #如前面不定义name，默认process-1 etc
    p1.terminate()     #向操作系统发请求，父进程无需等待
    p1.join()          #等待该子进程结束（卡住吧），父进程需要等待一点时间
    print(p1.is_alive())
    print('主')       #这里的效果是主进程等儿子死了，再结束

from multiprocessing import Process
import time,os

def task():
    print('self:%s parent:%s' %(os.getpid(),os.getppid()))
    time.sleep(3)

if __name__ == '__main__':
    p1=Process(target=task,)
    p1.start()
    print(p1.pid)
print('主',os.getpid())

六、僵尸进程与孤儿进程
在unix系统中init是所有进程的爹；创建进程用fork，回收进程（结束进程的残留信息？）用waitpid
僵尸进程（有害：占用pid）：子代先于父代终结，其部分信息（pid等）没有从系统中删除，需要父代回收。join中含有回收子代信息的功能。
孤儿进程（无害）：父代先于子代终结，子代终结后的部分信息由init代收。

from multiprocessing import Process
import time,os

def task(n):
    print('%s is running' %n)
    time.sleep(n)

if __name__ == '__main__':
1=Process(target=task,args=(1,))
    p1.start()
    p1.join()     # join中含有回收子代信息的功能（wait）
    print('======主',os.getpid())

七、守护进程

父进程代码运行完(主线程运行代码)，守护进程就结束
from multiprocessing import Process
import time

def task(name):
print('%s is running' % name)
time.sleep(3)

if __name__ == '__main__':
    obj = Process(target=task, args=('egon',))
    obj.daemon=True    #将obj变成守护进程，主进程执行完毕后子进程跟着结束
    obj.start() # 发送信号给操作系统
　 print('主')

八、互斥锁
强调：必须是lock.acquire()一次，然后 lock.release()释放一次，才能继续lock.acquire()，不能连续的lock.acquire()。否者程序停在原地。
   　　抢同一把锁：生成锁对象必须放在if __name__=='__main__': 下面
互斥锁vs join：
大前提：二者的原理都是一样，都是将并发变成串行，从而保证有序（在多个程序共享一个资源时，为保证有序不乱，需将并发变成串行）
场景: 修改公共数据，如果并发会发出数据错乱，这时就必须串行执行，就要用到互斥锁
区别一：join是按照人为指定的顺序执行，而互斥锁是所以进程平等地竞争，谁先抢到谁执行
区别二：互斥锁可以让一部分代码串行，而join只能将代码整体串行（详见抢票系统）
  理解：首先join肯定是一个子进程对象，互斥锁可以加在子进程对象代码任意部位（要释放额）
     join人为安排子进程执行顺序，互斥锁是公平竞争。

from multiprocessing import Process,Lock
import time,random

mutex=Lock() #这里每个子进程的都会申请一把锁
print(id(mutex))

def task1(lock):
     lock.acquire()
#   print('task1:名字是egon')
#   time.sleep(random.randint(1,3))
#   print('task1:性别是male')
     time.sleep(random.randint(1,3))      #with mutex: time.sleep(random.randint(1,3))
#   print('task1:年龄是18')
     lock.release()

def task2(lock):
    lock.acquire()
    print('task2:名字是alex')
    time.sleep(random.randint(1,3))
    print('task2:性别是male')
    time.sleep(random.randint(1,3))
    print('task2:年龄是78')
    lock.release()

def task3(lock):
    lock.acquire()
    print('task3:名字是lxx')
    time.sleep(random.randint(1,3))
    print('task3:性别是female')
    time.sleep(random.randint(1,3))
    print('task3:年龄是30')
    lock.release()

if __name__ == '__main__':
    p1=Process(target=task1,args=(mutex,))
    p2=Process(target=task2,args=(mutex,))
    p3=Process(target=task3,args=(mutex,))

    p1.start()
    p2.start()
    p3.start()

last、抢票系统
import json
import time
import random
import os
from multiprocessing import Process,Lock

mutex=Lock() #每个子进程都会生成一把锁对象，没用到。可以优化放在下面 __name__里面

def search():
    time.sleep(random.randint(1,3))
    with open('db.json','r',encoding='utf-8') as f:
        dic=json.load(f)
        print('%s 剩余票数:%s' %(os.getpid(),dic['count']))

def get():
    with open('db.json','r',encoding='utf-8') as f:
        dic=json.load(f)
    if dic['count'] > 0:
        dic['count']-=1
        time.sleep(random.randint(1,3))
        with open('db.json','w',encoding='utf-8') as f:
            json.dump(dic,f)
        print('%s 购票成功' %os.getpid())

def task(lock):
    search()
    lock.acquire()
    get()
    lock.release()

if __name__ == '__main__':
    for i in range(10):
        p=Process(target=task,args=(mutex,)) #这里子进程用的都是主进程这一把锁 id
        p.start()

(并发编程)进程 (multiprocessing--Process实现进程并发）的更多相关文章

Java并发编程的艺术读书笔记(1)-并发编程的挑战
title: Java并发编程的艺术读书笔记(1)-并发编程的挑战 date: 2017-05-03 23:28:45 tags: ['多线程','并发'] categories: 读书笔记 --- ...
Java并发编程的艺术读书笔记(2)-并发编程模型
title: Java并发编程的艺术读书笔记(2)-并发编程模型 date: 2017-05-05 23:37:20 tags: ['多线程','并发'] categories: 读书笔记 --- 1 ...
那些年读过的书《Java并发编程实战》和《Java并发编程的艺术》三、任务执行框架—Executor框架小结
<Java并发编程实战>和<Java并发编程的艺术> Executor框架小结 1.在线程中如何执行任务 (1)任务执行目标: 在正常负载情况下,服务器应用 ...
[书籍翻译] 《JavaScript并发编程》第七章抽取并发逻辑
本文是我翻译<JavaScript Concurrency>书籍的第七章抽取并发逻辑,该书主要以Promises.Generator.Web workers等技术来讲解JavaScrip ...
java并发编程笔记（九）——多线程并发最佳实践
java并发编程笔记(九)--多线程并发最佳实践使用本地变量使用不可变类最小化锁的作用域范围使用线程池Executor,而不是直接new Thread执行宁可使用同步也不要使用线程的wait ...
并发编程——多进程——multiprocessing开启进程的方式及其属性（3）
开启进程的两种方式——Process 方式一:函数方法 from multiprocessing import Process import time def task(name): print('% ...
03并发编程（多道技术+进程理论+进程join方法）
目录 03 并发编程 03 并发编程
Java并发编程（一）：进程和线程之由来
转自:http://www.cnblogs.com/dolphin0520/p/3910667.html 在前面,已经介绍了Java的基础知识,现在我们来讨论一点稍微难一点的问题:Java并发编程.当 ...
并发编程7 管道&事件&信号量&进程池(同步和异步方法)
1,管道 2.事件 3.信号量 4.进程池的介绍&&进程池的map方法&&进程池和多进程的对比 5.进程池的同步方法和异步方法 6.重新解释同步方法和异步方法 7.回调 ...
进程 multiprocessing Process join Lock Queue
多道技术 1.空间上的复用多个程序公用一套计算机硬件 2.时间上的复用 cpu 切换程序+保存程序状态 1.当一个程序遇到IO操作,操作系统会剥夺该程序的cpu执行权限(提高了cpu的利用率,并且不 ...

随机推荐

在kubernetes集群上用helm安装Datadog(Monitoring)
Datadog is a monitoring service that gathers monitoring data from your containers within your Azure ...
CF710F String Set Queries
CF710F String Set Queries 支持字符串的插入和删除...SAM也干不了这个事所以可以用cdq分治+AC自动机O(nlogn)解决但是本题强制在线~~~ 我们还有一个工具,叫 ...
洛谷P4145 上帝造题的⑦minutes ②
又是线段树. 区间开平方求和,套路题. 如果开到了1就不用再开下去了,否则直接到底. 记得 l > r 时交换 l r #include <cstdio> #include < ...
CENTOS 6.6初始化SHELL脚本
时间:2016-02-24 00:30来源:blog.51cto.com 作者:“xxlixin” 博客举报点击:1717次这个脚本是在刚安装完CENTOS6.6后可能需要进行的操作.在学习CE ...
ADO.NET入门教程（五）细说数据库连接池
摘要今天我要讲的是数据库连接池.说实话,我表示鸭梨很大.因为相比其他章节来说,连接池相对来说难理解一点.我要用最通俗的语句给大家讲明白,讲透彻却也不是一件很容易的事.但是,连接池又是非常重要的知识点 ...
MySQL 5.6版本内存占用过高的解决办法
最近在阿里云购买了一台云服务器,因为是自己测试玩的,所以配置按最低的来了,1G内存,然后啪啪啪(指键盘声音)的安装了JDK,Tomcat,MySQL(5.6)等一系列环境,开始很爽,然后噩梦开始了: ...
BigDecimal最基础用法【转】
BigDecimal最基础用法用字符串生成的BigDecimal是不会丢精度的. 简单除法. public class DemoBigDecimal { public static void mai ...
epoll讲解--转自知乎
Ctrip AIO底层使用epoll https://blog.csdn.net/z69183787/article/details/52943637 首先我们来定义流的概念,一个流可以是文件,soc ...
流媒体技术学习笔记之（二）RTMP和HLS分发服务器nginx.conmf配置文件(解决了,只能播放RTMP流而不能够播放HLS流的原因)
user www www; worker_processes ; error_log logs/error.log debug; #pid logs/nginx.pid; events { worke ...
【C++ STL】Set和Multiset
1.结构 set和multiset会根据特定的排序原则将元素排序.两者不同之处在于,multisets允许元素重复,而set不允许重复. 只要是assignable.copyable.comparab ...

(并发编程)进程 (multiprocessing--Process实现进程并发）

(并发编程)进程 (multiprocessing--Process实现进程并发）的更多相关文章

随机推荐

热门专题