python3 进程3

管道

在内存中开辟一个管道空间，对多个进程可见。在通信形式上形成一种约束；

linux 文件类型

b c d - l s p

目录普通文件链接套接字管道

multiprocessing -----> Pipe函数

Pipe(duplex)

功能：创建一个管道

参数：duplex 默认为True 表示管道为双向管道（全双工）；

如果设置为False，则表示管道为单向管道；

返回值：返回两个管道流对象，分配表示管道的两端；

如果参数为True（默认），两个对象均可发送接收；

如果为False时，则第一个对象只能接收，第二个对象只能发送；

说明：1，向管道发送数据使用send()函数，从管道接收数据使用recv() 函数；

2，recv() 函数为阻塞函数，当管道中数据为空时会阻塞；

3，一次recv() ，只能接收一次send()的内容；

4，send() 可以发送字符串数字列表等多种类型数据；

 from multiprocessing import Process,Pipe

 import os,time

 #创建管道对象

 #当参数为False的时候child只能recv parent只能send

 # child_conn,parent_conn = Pipe(False)

 child_conn,parent_conn = Pipe()

 #子进程函数

 def fun(name):

     time.sleep(1)

     #发送一个字符串到管道

     child_conn.send('hello' + str(name))

     print(os.getppid(),"----",os.getpid())

 jobs = []

 #创建５个子进程

 for i in range(5):

     p = Process(target = fun,args = (i,))

     jobs.append(p)

     p.start()

 for i in range(5):

     data = parent_conn.recv()

     print(data)

 for i in jobs:

     i.join()

消息队列：

multiprocessing ---> Queue

在内存中开辟一个队列模型，用来存放消息，任何拥有队列队形的进程都可以进行消息的存放和取出；

Queue(maxsize = 0)

功能：创建一个消息队列对象；

参数：maxsize 默认为0 表示消息队列可以存放的消息由系统自动分配的空间而定；

> 0 的正整数表示队列中最多存放多少条消息；

返回值：消息队列对象；

q.put()

1，向消息队列中存放一条消息，当消息队列满的时候，会阻塞；

2，存放的消息类型可以是数字，列表，字符串等；

q.full()

判断队列是否为满，如果满则返回True，否则返回False；

q.qsize()

查看当前队列中消息数量；

q.get()

获取消息，每次获取一条；当消息队列为空时，则为阻塞；

说明： put() 、get() 中block参数和timeout参数

block默认为True，表示两个函数都是阻塞函数；

如果设置为False，则表示不阻塞；

timeout 当block设置为True时，表示超时等待时间；

 from multiprocessing import Queue 

 #创建消息队列对象

 q = Queue(3)

 i = 0

 # 存放消息　

 while True:

     #判断队列是否满了

     if q.full():

         print("queue is full")

         break

     q.put("hello" + str(i))

     i += 1

 print("当前队列有%d条消息"%q.qsize())

 for i in range(q.qsize()):

     print("获取消息%s"%q.get())

 print("is empty?",q.empty())

 print(q.get(True,3))

 print("process over")

 from multiprocessing import Process,Queue

 import time 

 q = Queue()

 def fun(name):

     time.sleep(1)

     q.put("hello" + str(name))

 jobs = []

 for i in range(10):

     p = Process(target = fun,args =(i,))

     jobs.append(p)

     p.start()

 for i in jobs:

     i.join()

 while not q.empty():

     print(q.get())

共享内存

在内存中开辟一段内存空间存储数据，每次存储的内容会覆盖上次的内容；由于没有对内存进行格式化修饰，所以存储的速度快效率高；

from multiprocessing import Value,Array

obj = Value(ctype, obj)

功能：开辟共享内存

参数：ctype 要转变的c的类型

obj 要写入共享内存的初始值

obj.value 属性为获取共享内存中的值；

 from multiprocessing import Value,Process

 import time

 import random 

 def deposite(money):

     for i in range(100):

         time.sleep(0.03)

         money.value += random.randint(1,200) 

 def withdraw(money):

     for i in range(100):

         time.sleep(0.02)

         money.value -= random.randint(1,150) 

 money = Value('i',2000)

 d = Process(target = deposite,args = (money,))

 w = Process(target = withdraw,args = (money,))

 d.start()

 w.start()

 d.join()

 w.join()

 print(money.value)

obj =Array(ctype, obj)

功能：开辟一个共享内存空间；

参数：要装的c的类型；

obj 放入共享内存中的数据，是一个列表，要求列表重点数据为相同类型的数据；

如果obj传入一个正数，则表示在共享内存中开辟一个多大的空间，空间中可以存放的数值类型由ctype确定；

返回值：返回一个可迭代对象通过for循环取值，可以进行修改；

from multiprocessing import Process,Array

import time

import ctypes

def fun(shm):

    for i in shm:

        print(i)

    # shm[0] = 'A'

# shm = Array('i',[1,2,3,4,5])

shm = Array(ctypes.c_char,6)

p = Process(target = fun,args = (shm,))

p.start()

p.join()

for i in shm:

    print(i)

############

管道消息队列共享内存

开辟空间：内存中内存中内存中

读写方式：可双向/单向先进先出，按照个数存储操作内存

效率：一般一般较快

是否需要同步互斥：不需要不需要需要

#############

信号：

kill -l 查看系统信号

kill -signame PID 给进程号PID的进程发送signame信号；

信号：信号名称含义默认处理方式

名称：系统定义

含义：系统定义

处理方式：采用默认方式处理（系统定义终止暂停忽略）

忽略信号（当信号没发生过）

采用自定义方式处理

 import signal

 import time

 signal.alarm(5)

 #采用默认方式

 # signal.signal(signal.SIGINT,signal.SIG_DFL)

 #忽略该信号

 signal.signal(signal.SIGINT,signal.SIG_IGN)

 signal.signal(signal.SIGALRM,signal.SIG_IGN)

 while True:

     time.sleep(2)

     print("你按ctrl + c啊")

 from signal import *

 import os,time 

 #信号处理函数，有固定参数格式

 def handler(sig,frame):

     if sig == SIGALRM:

         print("收到了时钟信号")

     elif sig == SIGINT:

         print("收到了SIGINE就不结束")

 alarm(7)

 #通过函数　处理信号

 signal(SIGALRM,handler)

 signal(SIGINT,handler)

 while True:

     print("waiting for signal")

     time.sleep(2)

如何发送信号：

os.kill(pid, sig)

功能：向一个进程发送一个信号

参数：pid 指要发送进程的PID号

sig 指要发送的信号

signal.alarm(sec)

功能：给自己发送一个时钟信号（SIGALRM）

参数：esc 秒数表示在相应的秒数后发送时钟信号

说明：1，信号是一种异步的进程间通信方式

2，alarm函数在一个进程中如果使用多次，则后面的时钟时间会覆盖前面的时间。

信号的处理：

signal.pause() 阻塞等待一个信号的发生；

signal.signal(signum, hander)

功能：处理信号

参数：signum 表示可以处理的信号

hander 信号处理的方法：

1，默认处理方式：SIG_DFL

2，忽略信号：SIG_IGN

　　　　　　 3，自定义的方式： function

说明：1， signal 函数也是一个异步处理信号函数；

2， SIGSTOP 和SIKILL不能被signal函数处理；

####

僵尸进程的信号处理方案父进程中

signal(SIGCHLD, SIG_IGN)

###

同步和互斥

临界资源：对多个进程或者线程都可见的资源，容易产生争夺，我们将这类资源叫做临界资源；

临界区：对临界资源进行操作的代码区域称之为临界区；

解决资源争夺方法：同步或者互斥

同步：同步是一种合作关系，为完成某种任务而建立的多个进程或者线程之间的协调调用，持续等待，传递消息告知资源占用情况；

互斥：互斥是一种制约关系，当一个进程或者线程进入到临界区后会进行枷锁操作，此时其他进程或者线程无法进入到临界区，只有

当该进程或线程使用后进程解锁，其他人才可以使用，这种技术往往是通过阻塞完成；

Event 事件

Event() ----> 事件对象e

e.wait() : 产生一种阻塞，知道e被set之后才结束阻塞
e.set() ：将e set操作 wait不再阻塞
e.is_set() : 判断e是否是被设置的状态
e.clear() ：将e 变成没有被设置的状态

 from multiprocessing import Event 

 #生成事件对象　

 e = Event() 

 #检测事件对象，如果被设置则返回True否则返回false

 print(e.is_set())

 #设置事件对象

 e.set()

 #提供事件的阻塞

 e.wait()

 print("wait.....")

 #清除对事件的设置

 e.clear()

 e.wait()

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

 from  multiprocessing import Process,Event

 import time 

 def wait_event():

     print('process1要等主进程操作完我才能操作')

     e.wait()

     print('终于操作完了，该我了',e.is_set())

 def wait_event_timeout():

     print('process2要等主进程操作完我才能操作')

     e.wait(2)

     print('我等不了了，干别的去',e.is_set())

 e = Event() 

 p1 = Process(name = 'block',\

     target = wait_event)

 p1.start()

 p2 = Process(name = 'non-block',\

     target = wait_event_timeout)

 p2.start()

 print("假设主进程在忙碌的操作临界区")

 time.sleep(3)

 e.set()

 print("主进程开放临界区")

练习：

1. 创建父子进程，分别表示司机和售票员

2. 当售票员捕捉到 SIGINT信号时给司机发送SIGUSR1信号，
司机打印“老司机开车了”

当售票员捕捉到 SIGQUIT信号时给司机发送SIGUSR2信号，
司机打印“系好安全带，小心甩出去”

当司机捕捉到 SIGTSTP信号时给售票员发送SIGUSR1信号，
售票员打印“到站了，下车吧”

3. 到站后售票员先下车（子进程先退出），然后司机下车

 from signal import *

 from multiprocessing import Process

 import os

 import time 

 def saler_handler(sig,frame):

     if sig == SIGINT:

         os.kill(os.getppid(),SIGUSR1)

     elif sig == SIGQUIT:

         os.kill(os.getppid(),SIGUSR2)

     elif sig == SIGUSR1:

         print("python学完了，出去试试吧")

         os._exit(0)

 def driver_handler(sig,frame):

     if sig == SIGUSR1:

         print("老司机带你学python")

     elif sig == SIGUSR2:

         print("python 知识多，积累最重要")

     elif sig == SIGTSTP:

         os.kill(p.pid,SIGUSR1)

 def saler():

     signal(SIGINT,saler_handler)

     signal(SIGQUIT,saler_handler)

     signal(SIGUSR1,saler_handler)

     signal(SIGTSTP,SIG_IGN)

     while True:

         time.sleep(2)

         print("开着python去远方")

 p = Process(name = 'zhangjie',\

     target = saler)

 p.start()

 # 父进程处理信号部分

 signal(SIGUSR1,driver_handler)

 signal(SIGUSR2,driver_handler)

 signal(SIGTSTP,driver_handler)

 signal(SIGINT,SIG_IGN)

 signal(SIGQUIT,SIG_IGN)

 p.join()

巴特西

Python之路PythonThread，第三篇，进程3

python3 进程3

最新文章

热门文章