一 守护进程

1.1 基本概念

守护进程

  • 正常情况下,主进程默认等待子进程调用结束之后结束
  • 守护进程在主进程执行代码结束后,自动终止

守护进程语法:

  • 进程对象.daemon = True ，设置该进程是守护进程
  • 守护进程需要在start()方法之前设置
  • 为主进程守护,主进程如果代码执行结束了,该守护进程自动结束.

1.2 基本语法

import os

import time

from multiprocessing import Process

def func():

        print("子进程start")

        print("子进程end")

p = Process(target=func)

p.start()

print ("主进程执行结束")

执行

[root@node10 python]# python3 test.py

主进程执行结束

子进程start

子进程end

使用守护进程

import os

import time

from multiprocessing import Process

def func():

        print("子进程start")

        print("子进程end")

p = Process(target=func)

p.daemon = True

p.start()

print ("主进程执行结束")

执行

[root@node10 python]# python3 test.py

主进程执行结束

主进程执行完之后，子进程不在执行

1.3 多个子进程情况

import os

import time

from multiprocessing import Process

def func1():

        count = 1

        while True:

                print ("*" * count)

                time.sleep(0.5)

                count += 1

def func2():

        print("func2 start")

        time.sleep(3)

        print("func2 end")

p1 = Process(target=func1)

p1.start()

p2 = Process(target=func2)

p2.start()

print ("主进程执行结束")

执行

[root@node10 python]# python3 test.py

主进程执行结束

*

func2 start

**

***

****

*****

******

func2 end

*******

********

*********

**********

***********

************

*************

**************

***************

****************

*****************

******************

*******************

********************

*********************

**********************

第一个进程不能结束，设置一个守护进程

import os

import time

from multiprocessing import Process

def func1():

        count = 1

        while True:

                print ("*" * count)

                time.sleep(0.5)

                count += 1

def func2():

        print("func2 start")

        time.sleep(3)

        print("func2 end")

p1 = Process(target=func1)

p1.daemon = True

p1.start()

p2 = Process(target=func2)

p2.start()

print ("主进程执行结束")

但这种添加还没来得及执行，就被杀掉

执行

[root@node10 python]# python3 test.py

主进程执行结束

func2 start

func2 end

当多个子进程并发执行时,默认主进程等待子进程的

如果标记该子进程是守护进程，当主进程执行完所有代码之后,守护进程立刻终止

主进程代码执行到最后一行,就意味着守护进程终止了，其他非守护进程继续执行,主进程仍然会等待他执行结束，最后主进程在真正的释放结束.

1.4 守护进程用途: 报活功能

import os

import time

from multiprocessing import Process

def alive():

        while True:

                print ("I am the first server,I'm  OK")

                time.sleep(0.5)

def func():

        print("The first server is used to collect logs")

        time.sleep(5)   #相当于这个进程存活5s

p1 = Process(target=alive)

p1.daemon = True

p1.start()

p2 = Process(target=func)

p2.start()

#模拟func程序结束，或者服务器宕机,停止保活,这是执行主进程，执行完，则子进程不在执行，即停止报活

p2.join()

print (".......")

执行

[root@node10 python]# python3 test.py

I am the first server,I'm  OK

The first server is used to collect logs

I am the first server,I'm  OK

I am the first server,I'm  OK

I am the first server,I'm  OK

I am the first server,I'm  OK

I am the first server,I'm  OK

I am the first server,I'm  OK

I am the first server,I'm  OK

I am the first server,I'm  OK

I am the first server,I'm  OK

.......

二 lock锁

语法:

# 创建一把锁

lock = lock()

# 上锁

lock.acquire()

# 解锁

lock.release()

2.1 基本用法

import os

import time

from multiprocessing import Process,Lock

lock = Lock()

lock.acquire()

lock.release()

print (111)

执行

[root@node10 python]# python3 test.py

111

死锁 上锁和解锁之间不匹配,只上锁不解锁就是死锁,会产生阻塞;

import os

import time

from multiprocessing import Process,Lock

lock = Lock()

lock.acquire()

#lock.release()

print (111)

执行就会被阻塞，而且不会打印111，成了一把死锁

2.2 模拟一个抢票机制

假设只有一张票

[root@node10 python]# vim ticket

{"count": 1}

抢票方法

import os

import time,json

from multiprocessing import Process,Lock

def wr_info(sign,dic=None):

        if sign == "r":

                with open("ticket",mode="r",encoding="utf-8") as fp:

                        dic = json.load(fp)

                return dic

        elif sign == "w":

                with open("ticket",mode="w",encoding="utf-8") as fp:

                        json.dump(dic,fp)

#抢票方法

def get_ticket(person):

        dic = wr_info("r")

        time.sleep(0.11)

        if dic["count"] > 0:

                print("%s抢到票"%(person))

                dic["count"] -=1

#               更新数据库

                wr_info("w",dic)

        else:

                print ("%s没有买到票"%(person))

#用ticket来仅从统一调用

def ticket(person):

        #查询票数

        dic = wr_info("r")

        print ("%s查询余票：%s"%(person,dic['count']))

        get_ticket(person)

for i in range(10):

        p = Process(target = ticket,args=( "person%s" %(i), ))

        p.start()

执行

[root@node10 python]# python3 test.py

person0查询余票：1

person1查询余票：1

person2查询余票：1

person3查询余票：1

person4查询余票：1

person5查询余票：1

person6查询余票：1

person7查询余票：1

person8查询余票：1

person9查询余票：1

person3抢到票

person0抢到票

person4抢到票

person5抢到票

person1抢到票

person7抢到票

person2抢到票

person6抢到票

person8抢到票

person9抢到票

发现所有人都抢到票了

2.3 使用锁机制

在主进程创建一把锁，在抢票处上锁，然后再抢完解锁，如下操作

import os

import time,json

from multiprocessing import Process,Lock

def wr_info(sign,dic=None):

        if sign == "r":

                with open("ticket",mode="r",encoding="utf-8") as fp:

                        dic = json.load(fp)

                return dic

        elif sign == "w":

                with open("ticket",mode="w",encoding="utf-8") as fp:

                        json.dump(dic,fp)

#抢票方法

def get_ticket(person):

        dic = wr_info("r")

        time.sleep(0.11)

        if dic["count"] > 0:

                print("%s抢到票"%(person))

                dic["count"] -=1

#               更新数据库

                wr_info("w",dic)

        else:

                print ("%s没有买到票"%(person))

#用ticket来仅从统一调用

#这里需要把lock传进来

def ticket(person,lock):

        #查询票数

        dic = wr_info("r")

        print ("%s查询余票：%s"%(person,dic['count']))

        lock.acquire()

        get_ticket(person)

        lock.release()

lock = Lock()

for i in range(10):

        p = Process(target = ticket,args=( "person%s" %(i), ))

        p.start()

执行

主进程在执行ticket的子进程时，多一个参数

import os

import time,json

from multiprocessing import Process,Lock

def wr_info(sign,dic=None):

        if sign == "r":

                with open("ticket",mode="r",encoding="utf-8") as fp:

                        dic = json.load(fp)

                return dic

        elif sign == "w":

                with open("ticket",mode="w",encoding="utf-8") as fp:

                        json.dump(dic,fp)

#抢票方法

def get_ticket(person):

        dic = wr_info("r")

        time.sleep(0.11)

        if dic["count"] > 0:

                print("%s抢到票"%(person))

                dic["count"] -=1

#               更新数据库

                wr_info("w",dic)

        else:

                print ("%s没有买到票"%(person))

#用ticket来仅从统一调用

#这里需要把lock传进来

def ticket(person,lock):

        #查询票数

        dic = wr_info("r")

        print ("%s查询余票：%s"%(person,dic['count']))

        lock.acquire()

        get_ticket(person)

        lock.acquire()

lock = Lock()

for i in range(10):

        p = Process(target = ticket,args=( "person%s" %(i), lock))

        p.start()

执行

[root@node10 python]# python3 test.py

person0查询余票：1

person1查询余票：1

person2查询余票：1

person3查询余票：1

person4查询余票：1

person5查询余票：1

person6查询余票：1

person7查询余票：1

person8查询余票：1

person9查询余票：1

person0抢到票

person1没有买到票

person2没有买到票

person3没有买到票

person4没有买到票

person5没有买到票

person6没有买到票

person7没有买到票

person8没有买到票

person9没有买到票

或者直接加锁

import os

import time,json

from multiprocessing import Process,Lock

def wr_info(sign,dic=None):

        if sign == "r":

                with open("ticket",mode="r",encoding="utf-8") as fp:

                        dic = json.load(fp)

                return dic

        elif sign == "w":

                with open("ticket",mode="w",encoding="utf-8") as fp:

                        json.dump(dic,fp)

#抢票方法

def get_ticket(person):

        dic = wr_info("r")

        time.sleep(0.11)

        if dic["count"] > 0:

                print("%s抢到票"%(person))

                dic["count"] -=1

                #更新数据库

                wr_info("w",dic)

        else:

                print ("%s没有买到票"%(person))

#用ticket来进行统一调用

#这里需要把lock传进来

def ticket(person):

        #查询票数

        dic = wr_info("r")

        print ("%s查询余票：%s"%(person,dic['count']))

        lock.acquire()

        #开始抢票

        get_ticket(person)

        lock.release()

lock = Lock()

for i in range(10):

        p = Process(target = ticket,args=( "person%s"%(i),))

        p.start()

区分同步和异步

  • 在产生进程对象的时候,进程之间是异步的.上锁之后,进程是同步的
  • 必须等上一个进程执行完毕之后,下一个进行才能执行,这个是同步.

三  信号量

Semaphore 本质上就是锁,只不过可以控制锁的数量

模拟取钱，假设10个人排队取钱

import os

import time,json

from multiprocessing import Process,Lock,Semaphore

def bank(person):

        print ("%s进入柜台取钱"%(person))

        print ("%s取完离开"%(person))

for i in range(10):

        p = Process(target = bank,args=("person%s"%(i),))

        p.start()

执行

[root@node10 python]# python3 test.py

person0进入柜台取钱

person0取完离开

person1进入柜台取钱

person1取完离开

person2进入柜台取钱

person2取完离开

person3进入柜台取钱

person3取完离开

person4进入柜台取钱

person4取完离开

person5进入柜台取钱

person5取完离开

person6进入柜台取钱

person6取完离开

person7进入柜台取钱

person7取完离开

person8进入柜台取钱

person8取完离开

person9进入柜台取钱

person9取完离开

假设4个柜台使用semaphore上四把锁

import os

import time,json

from multiprocessing import Process,Lock,Semaphore

def bank(person):

        sem.acquire()

        time.sleep(5)

        print ("%s进入柜台取钱"%(person))

        print (os.getpid())

        res = os.popen("date").read()

        print(res)

        sem.release()

        print ("%s取完离开"%(person))

sem = Semaphore(4)

for i in range(10):

        p = Process(target = bank,args=("person%s"%(i),))

        p.start()

执行

person0进入柜台取钱

person3进入柜台取钱

4502

4505

Sat Feb 22 21:58:07 EST 2020

Sat Feb 22 21:58:07 EST 2020

person0取完离开

person3取完离开

person1进入柜台取钱

4503

Sat Feb 22 21:58:07 EST 2020

person1取完离开

person2进入柜台取钱

4504

Sat Feb 22 21:58:07 EST 2020

person2取完离开

person5进入柜台取钱

4507

Sat Feb 22 21:58:12 EST 2020

person5取完离开

person6进入柜台取钱

4508

Sat Feb 22 21:58:12 EST 2020

person6取完离开

person7进入柜台取钱

person4进入柜台取钱

4506

4509

Sat Feb 22 21:58:12 EST 2020

person4取完离开

Sat Feb 22 21:58:12 EST 2020

person7取完离开

person8进入柜台取钱

4510

Sat Feb 22 21:58:17 EST 2020

person8取完离开

person9进入柜台取钱

4511

Sat Feb 22 21:58:17 EST 2020

person9取完离开

根据时间，每次四个一次

四 事件

4.1 基本概念

阻塞事件 ：

  1. e = Event()生成事件对象e
  2. e.wait()动态给程序加阻塞 , 程序当中是否加阻塞完全取决于该对象中的is_set()

[默认返回值是False]

  • 如果是True 不加阻塞
  • 如果是False 加阻塞

控制这个属性的值

  • set()方法 将这个属性的值改成True
  • clear()方法 将这个属性的值改成False
  • is_set()方法 判断当前的属性是否为True (默认上来是False)

4.2 基本语法

默认时False

from multiprocessing import Process,Event

e = Event()

print (e.is_set())

执行

[root@node10 python]# python3 test.py

False

使用阻塞

from multiprocessing import Process,Event

e = Event()

print (e.is_set())

e.wait(5)   #相当于sleep

print ("事件")

执行

[root@node10 python]# python3 test.py

False

事件

set

from multiprocessing import Process,Event

e = Event()

e.set()

print (e.is_set())

e.wait()

print ("事件")

执行，直接打印

[root@node10 python]# python3 test.py

True    #不加阻塞

事件

Claen

e = Event() # True

e.set()

e.wait()

print(123)

e.clear() # False

e.wait()

print(456)

执行，456不会打印，因为clean后时False

[root@node10 python]# python3 test.py

123

4.3 模拟红绿灯效果

from multiprocessing import Process,Event

import time

def traffic_light(e):

        #默认红灯先亮

        print ("red")

        while True:

                if e.is_set():

                        #当前时绿灯

                        time.sleep(2)

                        #等完2秒，变红灯

                        print("red")

                        e.clear()

                else:

                        #当前时红灯

                        time.sleep(2)

                        #等完2秒，变绿灯

                        print ("blue")

                        e.set()

e = Event()

traffic_light(e)

执行

[root@node10 python]# python3 test.py

red

blue

red

blue

red

模拟车辆遇到红灯停，绿灯行

from multiprocessing import Process,Event

import time,random

def traffic_light(e):

        #默认红灯先亮

        print ("red")

        while True:

                if e.is_set():

                        #当前时绿灯

                        time.sleep(2)

                        #等完2秒，变红灯

                        print("red")

                        e.clear()

                else:

                        #当前时红灯

                        time.sleep(2)

                        #等完2秒，变绿灯

                        print ("blue")

                        e.set()

def car(e,i):

        if not e.is_set():

                print ("The car%s is wait"%(i))

                e.wait()

        print("car%s is running"%(i))

e = Event()

p1 = Process(target=traffic_light,args=(e,))

p1.start()

for i in range(20):

        time.sleep(random.uniform(0,2))

        p2 = Process(target=car,args = (e,i))

        p2.start()

执行

[root@node10 python]# python3 test.py

red

The car0 is wait

blue

car0 is running

car1 is running

red

The car2 is wait

blue

car2 is running

car3 is running

car4 is running

red

The car5 is wait

blue

car5 is running

car6 is running

red

The car7 is wait

The car8 is wait

The car9 is wait

The car10 is wait

blue

car10 is running

car8 is running

car9 is running

car7 is running

car11 is running

red

The car12 is wait

blue

car12 is running

car13 is running

car14 is running

red

The car15 is wait

The car16 is wait

blue

car15 is running

car16 is running

car17 is running

car18 is running

red

The car19 is wait

blue

car19 is running

red

4.4 使用守护进程

from multiprocessing import Process,Event

import time,random

def traffic_light(e):

        #默认红灯先亮

        print ("red")

        while True:

                if e.is_set():

                        #当前时绿灯

                        time.sleep(2)

                        #等完2秒，变红灯

                        print("red")

                        e.clear()

                else:

                        #当前时红灯

                        time.sleep(2)

                        #等完2秒，变绿灯

                        print ("blue")

                        e.set()

def car(e,i):

        if not e.is_set():

                print ("The car%s is wait"%(i))

                e.wait()

        print("car%s is running"%(i))

e = Event()

p1 = Process(target=traffic_light,args=(e,))

p1.daemon = True

p1.start()

for i in range(20):

        time.sleep(random.uniform(0,2))

        p2 = Process(target=car,args = (e,i))

        p2.start()

执行

red

The car0 is wait

The car1 is wait

The car2 is wait

blue

car0 is running

car1 is running

car2 is running

car3 is running

car4 is running

car5 is running

car6 is running

red

The car7 is wait

The car8 is wait

The car9 is wait

The car10 is wait

blue

car8 is running

car7 is running

car9 is running

car10 is running

car11 is running

red

The car12 is wait

blue

car12 is running

car13 is running

car14 is running

red

The car15 is wait

blue

car15 is running

car16 is running

car17 is running

red

The car18 is wait

The car19 is wait

卡在这里不执行，是因为car已经跑完，进程不再执行，卡在e.wait这里

使用join

from multiprocessing import Process,Event

import time,random

def traffic_light(e):

        #默认红灯先亮

        print ("red")

        while True:

                if e.is_set():

                        #当前时绿灯

                        time.sleep(2)

                        #等完2秒，变红灯

                        print("red")

                        e.clear()

                else:

                        #当前时红灯

                        time.sleep(2)

                        #等完2秒，变绿灯

                        print ("blue")

                        e.set()

def car(e,i):

        if not e.is_set():

                print ("The car%s is wait"%(i))

                e.wait()

        print("car%s is running"%(i))

e = Event()

lst = []

p1 = Process(target=traffic_light,args=(e,))

p1.daemon = True

p1.start()

for i in range(20):

        time.sleep(random.uniform(0,2))

        p2 = Process(target=car,args = (e,i))

        p2.start()

        lst.append(p2)

for i in lst:

        i.join()

print("程序彻底结束;")

执行

red

The car0 is wait

The car1 is wait

blue

car1 is running

car0 is running

car2 is running

car3 is running

red

The car4 is wait

blue

car4 is running

car5 is running

car6 is running

car7 is running

red

The car8 is wait

The car9 is wait

blue

car9 is running

car8 is running

car10 is running

red

The car11 is wait

blue

car11 is running

car12 is running

car13 is running

car14 is running

red

The car15 is wait

blue

car15 is running

car16 is running

car17 is running

red

The car18 is wait

The car19 is wait

blue

car19 is running

car18 is running

程序彻底结束;

041.Python守护进程，锁信号量和事件的更多相关文章

  1. Python守护进程和脚本单例运行

    Python 守护进程 守护进程简介 进程运行有时候需要脱离当前运行环境,尤其是Linux和Unix环境中需要脱离Terminal运行,这个时候就要用到守护进程.守护进程可以脱离当前环境要素来执行,这 ...

  2. Python实例浅谈之五Python守护进程和脚本单例运行

    一.简介 守护进程最重要的特性是后台运行:它必须与其运行前的环境隔离开来,这些环境包括未关闭的文件描述符.控制终端.会话和进程组.工作目录以及文件创建掩码等:它可以在系统启动时从启动脚本/etc/rc ...

  3. python 守护进程 daemon

    python 守护进程 daemon # -*-coding:utf-8-*- import sys, os '''将当前进程fork为一个守护进程 注意:如果你的守护进程是由inetd启动的,不要这 ...

  4. python 守护进程、同步锁、信号量、事件、进程通信Queue

    一.守护进程 1.主进程创建守护进程 其一:守护进程会在主进程代码执行结束后就终止 其二:守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes ...

  5. Python守护进程、进程互斥锁、进程间通信ICP（Queue队列）、生产者消费者模型

    知识点一:守护进程 守护进程:p1.daemon=True 守护进程其实就是一个“子进程“,守护=>伴随 守护进程会伴随主进程的代码运行完毕后而死掉 进程:当父进程需要将一个任务并发出去执行,需 ...

  6. Python之线程 3 - 信号量、事件、线程队列与concurrent.futures模块

    一 信号量 二 事件 三 条件Condition 四 定时器(了解) 五 线程队列 六 标准模块-concurrent.futures 基本方法 ThreadPoolExecutor的简单使用 Pro ...

  7. Python守护进程（多线程开发）

    本段代码主要作用是httpsqs队列的消费端守护进程,从httpsqs中取出数据,放入mongodb #!/usr/bin/python import sys,time,json,logging im ...

  8. Python 守护进程

    import os import sys from time import sleep try: pid = os.fork() if pid > 0: sys.exit(0) # Exit p ...

  9. python守护进程

    1.守护进程 [1]使用runner这个模块直接创建守护进程,非常方便. [2]运行方法:python xxx.py start|stop|restart [3]调用python xxx.py sto ...

随机推荐

  1. 1-Hyperledger Fabric概念详解

    目录 一.Hyperledger Fabric概述 二.基本术语 1.共享账本ledger 2.通道Channel 3.组织Org 4.智能合约Chaincode 5.背书Endorse 6.各种节点 ...

  2. pandas（5）：数学统计——描述性统计

    Pandas 可以对 Series 与 DataFrame 进行快速的描述性统计,方便快速了解数据的集中趋势和分布差异.源Excel文件descriptive_statistics.xlsx: 一.描 ...

  3. Tony老师带你来看Java设计模式：代理模式

    目录 定义 作用 意图 主要解决问题 优缺点 与装饰者模式的区别 结构 从Tony老师来看实现方式 静态代理 动态代理 JDK动态代理的实现 cglib动态代理的实现 定义 为其他对象提供一种代理来控 ...

  4. day16.网络编程1

    1 osi七层,tcp/ip 5层 1 cs架构和bs架构 2 互联网 3 osi七层.5层(5层名字记住:重点) -物理层 -网线,光纤 -数据链路层 -网卡 -网络层 -路由器 -传输层(运输层) ...

  5. Asp.Net Core&CAP实现分布式事务

    需要注意的是标题中的CAP不是指的CAP理论,而是园区大神杨晓东实现的框架,CAP框架基于本地消息表用最终一致性实现分布式事务. 本地消息表 首先我们考虑一个场景,在将用户信息更改后,需要发送一条消息 ...

  6. 『政善治』Postman工具 — 2、Postman主界面详细介绍

    目录 1.Postman菜单栏 (1)File 菜单 (2)Edit 菜单 (3)View 菜单 (4)Help 菜单 2.Postman工具栏 3.Postman工具栏中的系统设置 4.Postma ...

  7. 关于Spring Boot 多数据源的事务管理

    自己的一些理解:自从用了Spring Boot 以来,这近乎零配置和"约定大于配置"的设计范式用着确实爽,其实对零配置的理解是:应该说可以是零配置可以跑一个简单的项目,因为Spri ...

  8. Webshell和一句话木马

    目录 Webshell(大马) 一句话木马(小马) 一句话木马原理 一句话木马的变形 JSP后门脚本 Webshell(大马) 我们经常会看到Webshell,那么,到底什么是Webshell呢? w ...

  9. Tomcat漏洞集合

    目录 Tomcat的几大高危漏洞 Tomcat安全措施 Tomcat的几大高危漏洞 1.Tomcat后台弱口令上传war包(Tomcat管理弱口令页面Getshell) 2.Tomcat的PUT的上传 ...

  10. Win64 驱动内核编程-2.基本框架（安装.通讯.HelloWorld）

    驱动安装,通讯,Hello World 开发驱动的简单流程是这样,开发驱动安装程序,开发驱动程序,然后安装程序(或者其他程序)通过通讯给驱动传命令,驱动接到之后进行解析并且执行,然后把执行结果返回. ...