python 同步互斥信号量锁简介

Love The Way You Lie 2021-09-02 08:56 497阅读 0赞

**目录**

进程间的信号

信号量（信号灯）

进程的同步互斥

Event事件

Lock 锁

--------------------

### 进程间的信号 ###

信号是唯一的异步通信方法

一个进程向另一个进程发送一个信号来传递某种信息，接受者根据传递的信息来做相应的事

`$ kill -l`查看系统信号说明

`$ kill -9 pid号`对进程发送信号

<table> 
 <thead> 
  <tr> 
   <th>信号名称</th> 
   <th>说明</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1) SIGHUP</td> 
   <td>连接断开</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2) SIGINT</td> 
   <td>ctrl+c</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>3) SIGQUIT</td> 
   <td>ctrl+\</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>20) SIGTSTP</td> 
   <td>ctrl+z</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>9) SIGKILL</td> 
   <td>终止进程</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>19) SIGSTOP</td> 
   <td>暂停进程</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>26) SIGVTALRM</td> 
   <td>时钟信号</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>17) SIGCHLD</td> 
   <td>子进程退出时给父进程发的信号</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

在Python中`import signal`可以获取信号

`os.kill(pid, sig)`

功能：发送信号

参数

pid：要发送信号的PID号

sig ：信号名称

import os
    import signal
    os.kill(12345,signal.SIGKILL) #杀死进程

`signal.alarm(time)`

个人理解：把发送信号的信息告知系统内核，应用层程序继续运行，时间到之后利用内核告知应用层程序进行处理

功能：非阻塞函数，向自身进程发送一个时钟信号

参数：time->整型时间秒

import signal
      import time
      signal.alarm(3)#3秒后向自身发送一个时钟信号
      while True:
          time.sleep(1)
          print("等待时钟信号")
          
      '''打印结果
      等待时钟信号
      等待时钟信号
      闹钟
      '''

signal.alarm(3)#3秒后向自身发送一个时钟信号
      time.sleep(2)
      signal.alarm(5)#进程只有一个时钟信号，第二个会覆盖上面的时钟信号
      while True:
          time.sleep(1)
          print("等待时钟信号")
          
      '''打印结果
      等待时钟信号
      等待时钟信号
      等待时钟信号
      等待时钟信号
      闹钟
      '''

`signal.pause()`

功能：阻塞进程，然后等待信号

`signal.signal(signum, handler)`

功能：处理信号

参数

signum：要处理的信号

handler：信号的处理方法

`SIG_DFL`表示使用默认方法处理

`SIG_IGN`表示忽略这个信号

`function`表示传入一个函数，用指定的函数处理

def function(sig, frame)

sig：捕获到的信号

frame：信号对象

import signal
      from time import sleep
      
      signal.alarm(5)  # 5秒后向自身发送一个时钟信号
      # 使用信号的默认方法处理
      # signal.signal(signal.SIGALRM,signal.SIG_DFL)    
      # 忽略时钟信号
      # signal.signal(signal.SIGALRM,signal.SIG_IGN)
      # 忽略Ctrl+c信号
      # signal.signal(signal.SIGINT,signal.SIG_IGN)
      while True:
          sleep(2)
          print("等待时钟...")

# 使用自定义函数处理信号
      import signal
      from time import sleep
      
      def fun1(sig, frame):
          if sig == signal.SIGALRM :
              print("接收到时钟信号")
          elif sig == signal.SIGINT :
              print("ctrl+c就不结束")
      
      signal.alarm(5)  # 5秒后向自身发送一个时钟信号
      # 使用自定义函数处理信号
      # 处理时钟信号
      signal.signal(signal.SIGALRM,fun1)    
      # 处理ctrl+c信号
      signal.signal(signal.SIGINT,fun1)
      
      while True:
          print("等待")
          sleep(2)
          
      '''打印结果
      等待
      等待
      等待
      接收到时钟信号
      等待
      ...
      '''

### **信号量（信号灯）** ###

原理：给定一个数量对多个进程可见，且多个进程都可以操作，进程可以对数量多少的判断执行各自的行为

from multiprocessing import Semaphore
    
    sem = Semaphore(num)

功能：创建信号量

参数：信号量的初始值

返回值：信号量的对象

`sem.get_value()`：获取信号量的值

`sem.acquire()`：将信号量 -1，当信号为0时会阻塞

`sem.release()`：将信号量 +1

from multiprocessing import Semaphore, Process
    # 创建信号量对象
    sem = Semaphore(num)
    def fun():
        print("进程%d等待信号量"%os.getpid())
        # 消耗一个信号量
        sem.acquire()
        print("进程%d消耗信号量"%os.getpid())
        # 添加一个信号量
        sem.release()
        print("进程%d添加信号量"%os.getpid())
    
    jobs = []
    for i in range(4):
        p = Process(target = 4)
        jobs.append(p)
        p.start()
    for i in jobs:
        i.join()
    print(sem.get_value())

### **进程的同步互斥** ###

临界资源：多个进程或者线程都能操作的共享资源

临界区：操作临界区资源的代码段

同步：同步是一种合作关系，为完成某个任务，多进程或者多线程之间形成的一种协调关系

互斥：互斥是一种制约关系，

### Event事件 ###

`from multiprocessing import Event`

`e = Event()`：创建一个事件对象

`e.wait([timeout])`：设置事件阻塞

`e.set()`：事件设置，当事件被设置后`e.wait()`不再阻塞，等于释放资源区

`e.clear()`：清除设置，当事件被设置`e.clear()`后，`e.wait()`又会阻塞，阻塞资源区

`e.is_set()`：事件状态判断，判断事件是否处于被设置的状态

from multiprocessing import Event
    # 创建事件对象
    e = Event()
    # 查看
    print(e.is_set())        # False
    e.set()
    print(e.is_set())        # True
    e.wait(3)
    print(e.is_set())        # True
    e.clear()
    print(e.is_set())        # False

from multiprocessing import Event,Process
    from time import sleep
    
    def wait_event1():
        print("1想操作临界区资源")
        e.wait()
        print("1开始操作临界区资源",e.is_set())
        with open("file") as f:
            print(f.read())
    def wait_event2():
        print("2也想操作临界区资源")
        # 超时3秒检测
        e.wait(3)
        # 判断是否被设置
        if e.is_set():
            print("2开始操作临界区资源",e.is_set())
            with open("file") as f:
                print(f.read())
        else:
            print("2不能操作")       
    
    # 创建事件对象
    e = Event()
    p1 = Process(target = wait_event1)
    p2 = Process(target = wait_event2)
    p1.start()
    p2.start()
    print("主进程操作")
    with open("file",'w') as f:
        f.write("HELLO WORD")
    
    # 延迟4秒释放临界区
    sleep(4)
    # 释放临界区资源
    e.set()
    print("释放临界区")
    p1.join()
    p2.join()

### **Lock 锁** ###

`from multiprocessing import Lock`

`lock = Lock()`：创建一个锁对象

`lock.acquire()`：上锁，如果已经是上锁状态，调用此函数会阻塞

`lock.release()`：解锁

from multiprocessing import Lock,Process
    import sys
    def writer1():
        # 上锁
        lock.acquire()
        for i in range(20):
            sys.stdout.write("writer1111\n")
        # 解锁
        lock.release() 
    def writer2():
        # 上锁
        lock.acquire()
        for i in range(20):
            sys.stdout.write("writer2222\n")
        # 解锁
        lock.release()
    lock = Lock()
    
    w1 = Process(target = writer1)
    w2 = Process(target = writer2)
    
    w1.start()
    w2.start()
    w1.join()
    w2.join()

第二种方法

使用`with`语句上锁，with语句执行完毕后会自动解

with lock:
        .....
        .....