python实现多进程并发控制Semaphore与互斥锁LOCK

from multiprocessing import Process
from multiprocessing import Lock
import time
import random

def task1(p, lock):
    # 上锁
    lock.acquire()
    print(f'{p} 开始排泄')
    time.sleep(random.randint(1, 3))
    print(f'{p} 排泄结束')
    # 解锁
    lock.release()

def task2(p, lock):
    lock.acquire()
    print(f'{p} 开始排泄')
    time.sleep(random.randint(1, 3))
    print(f'{p} 排泄结束')
    lock.release()

def task3(p, lock):
    lock.acquire()
    print(f'{p} 开始排泄')
    time.sleep(random.randint(1, 3))
    print(f'{p} 排泄结束')
    lock.release()


if __name__ == '__main__':
    # 实例化一个锁对象
    mutex = Lock()
    # 将锁以参数的形式传入进程对象
    p1 = Process(target=task1, args=('task1', mutex,))
    p2 = Process(target=task2, args=('task2', mutex,))
    p3 = Process(target=task3, args=('task3', mutex,))

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

from multiprocessing import Process
from multiprocessing import Lock
import time
import random
import sys

def task1(p, lock):
    # 上锁
    lock.acquire()
    print(f'{p} 开始打印')
    time.sleep(random.randint(1, 3))
    print(f'{p} 打印结束')
    # 解锁
    lock.release()

def task2(p, lock):
    lock.acquire()
    print(f'{p} 开始打印')
    time.sleep(random.randint(1, 3))
    print(f'{p} 打印结束')
    lock.release()

def task3(p, lock):
    lock.acquire()
    print(f'{p} 开始打印')
    time.sleep(random.randint(1, 3))
    print(f'{p} 打印结束')
    lock.release()


if __name__ == '__main__':
    slock = Lock()
    for i in range(1,4):
       p = Process(target=getattr(sys.modules[__name__], f'task{i}'), args=(f'task{i}', slock))
       p.start()

# 举例说明：一间厕所有5个坑位，最多只能同时有5个人上厕所，当前时刻有20个人想上厕所，但是只能让5个人进去，然后出来多少个，才能进去多少个上厕所

# 从一个模块引用多个功能的时候，用逗号隔开
from threading import Semaphore, Thread, currentThread
import time
import random

sem = Semaphore(3)             # 并发执行数设置为5

def task():
    sem.acquire()
    print(f'{currentThread().name}')
    time.sleep(random.randint(1,3))
    sem.release()

if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=task)
        t.start()

import multiprocessing
import time

def worker(s, i):
    s.acquire()
    print(time.strftime('%Y-%m-%d %H:%M:%S'), multiprocessing.current_process().name + " 抢占并获得锁，运行")
    time.sleep(i)
    print(time.strftime('%Y-%m-%d %H:%M:%S'), multiprocessing.current_process().name + " 运行结束，释放锁")
    s.release()

if __name__ == '__main__':
    s = multiprocessing.Semaphore(2)
    for i in range(8):
        p = multiprocessing.Process(target=worker, args=(s, 1))
        p.start()

import multiprocessing
import time

def task1():
    n = 4
    while n > 1:
        print(f'{time.strftime("%Y-%M-%d %H:%M:%S")}  task1 输出信息')
        time.sleep(1)
        n -= 1

def task2():
    n = 4
    while n > 1:
        print(f'{time.strftime("%Y-%M-%d %H:%M:%S")}  task2 输出信息')
        time.sleep(1)
        n -= 1

def task3():
    n = 4
    while n > 1:
        print(f'{time.strftime("%Y-%M-%d %H:%M:%S")}  task3 输出信息')
        time.sleep(1)
        n -= 1

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=task1)
    p2 = multiprocessing.Process(target=task2)
    p3 = multiprocessing.Process(target=task3)
    p1.start()
    p2.start()
    p3.start()

import multiprocessing

import time

def task1(lock):
    with lock:
        n = 4
        while n > 1:
            print(f'{time.strftime("%Y-%M-%d %H:%M:%S")}  task1 输出信息')
            time.sleep(1)
            n -= 1

def task2(lock):
    lock.acquire()
    n = 4
    while n > 1:
        print(f'{time.strftime("%Y-%M-%d %H:%M:%S")}  task2 输出信息')
        time.sleep(1)
        n -= 1
    lock.release()

def task3(lock):
    lock.acquire()
    n = 4
    while n > 1:
        print(f'{time.strftime("%Y-%M-%d %H:%M:%S")}  task3 输出信息')
        time.sleep(1)
        n -= 1
    lock.release()

if __name__ == '__main__':
    lock = multiprocessing.Lock()
    p1 = multiprocessing.Process(target=task1, args=(lock,))
    p2 = multiprocessing.Process(target=task2, args=(lock,))
    p3 = multiprocessing.Process(target=task3, args=(lock,))
    p1.start()
    p2.start()
    p3.start()