python 信号平滑处理 python信号量怎么用

信号量：

给定一定的信号数量，对多个进程可见，并且多个进程均可操作。进程根据信号量的多少可以有不同的行为；

from multiprocess import Semaphore()

Semaphore(num)
功能: 定义信号量
参数： num 给定信号量的初始个数
返回值： 返回信号量对象

sem = Semaphore(num)
sem.acquire()    将信号量减一，将信号量为0时，调用会发生阻塞
sem.release()    将信号量加一

cookie:
mutiprocessing.current_process() 获取当前进程对象
 

from multiprocessing import Semaphore,current_process,Process
from time import sleep

#创建信号量，初始值为3
sem = Semaphore(3)

#自定义函数，用于打印信号量
def dealProcess():
    print('{} reduce Semaphore'.format(current_process()))
    sem.acquire()
    print('{} deal Semaphore'.format(current_process()))
    sleep(3)
    print('{} add Semaphore'.format(current_process()))
    sem.release()

jobs = []
for i in range(4):
    p = Process(target=dealProcess)
    p.start()
    jobs.append(p)

#回收进程
for j in jobs:
    j.join()

同步和互斥

目的：对共有资源的操作会产生争夺，同步互斥是一种解决争夺的方案

临界资源： 多个进程或线程都可以操作的资源；
临界区：    操作临界资源的代码段

同步：    同步是一种合作关系，为完成某个任务多进程或者多线程之间行政一种协调，
        按照条件次序执行，传递告知资源情况。这种协调可能是因为阻塞关系达成的；

互斥：  互斥是一种制约关系，当一个进程或者线程进入到临界区，会进行加锁的操作；
        此时其他进程或线程再企图获取资源时就会被阻塞，只有当资源被释放时才能继续操作；

同步互斥方法：
Event方法： 
    创建事件对象： e = Event()
    提供事件阻塞： e.wait()
    对事件对象进行设置，此时wait判断如果事件被set则结束阻塞： e.set()    
    清除对该时间的set： e.clear()        (如果后续再次e.wait(),则会再次阻塞)
    检测对象是否被设置，设置返回True/未设置False：e.is_set()        
 

from multiprocessing import Event,Process
from time import sleep

def fun_block():
    print('P1, I need the resource. waiting for block end....')
    e.wait()
    print('P1, Resource is ok, nice.True?:',e.is_set())

def fun_timeout():
    print('Processor2: I need the resource, waiting....')
    e.wait(3)
    print('P2, can not wait, True?: ',e.is_set())

e = Event()
p1 = Process(name = 'block' ,target=fun_block)
p2 = Process(name = 'time_out', target=fun_timeout)

p1.start()
p2.start()

print('Main: I am doing something import, Lock the resource.')
sleep(6)
e.set()
print('Main: process over, release the resource.')

p1.join()
p2.join()

Lock方法:
对资源的使用时，在操作资源的代码段，操作之前先加锁，操作之后解锁；这样可以自己独占资源，防止操作过程中被其他程序操作从而产生安全隐患;
lock = Lock()
lock.acquire()    加锁
lock.release()    解锁

注意： 在lock对象处于上锁状态的时候，再企图上锁则会阻塞，直到锁被释放，才能继续执行上锁操作；

with Lock:
    xxxxx
    xxxxx
---------------with代码段结束，自动解锁
 

from multiprocessing import Lock,Process
from time import sleep
import sys


def worker1():
    with lock:
        for i in range(5):
            sys.stdout.write('worker1.....\n')
            sleep(1)


def worker2():
    lock.acquire()
    for _ in range(5):
        sys.stdout.write('worker2.....\n')
        sleep(1)
    lock.release()

p1 = Process(target=worker1)
p2 = Process(target=worker2)

lock = Lock()

p1.start()
p2.start()

p1.join()
p2.join()