python實現(xiàn)多進(jìn)程并發(fā)控制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} 排泄結(jié)束')
    # 解鎖
    lock.release()

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

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


if __name__ == '__main__':
    # 實例化一個鎖對象
    mutex = Lock()
    # 將鎖以參數(shù)的形式傳入進(jìn)程對象
    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} 打印結(jié)束')
    # 解鎖
    lock.release()

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

def task3(p, lock):
    lock.acquire()
    print(f'{p} 開始打印')
    time.sleep(random.randint(1, 3))
    print(f'{p} 打印結(jié)束')
    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個人上廁所，當(dāng)前時刻有20個人想上廁所，但是只能讓5個人進(jìn)去，然后出來多少個，才能進(jìn)去多少個上廁所

# 從一個模塊引用多個功能的時候，用逗號隔開
from threading import Semaphore, Thread, currentThread
import time
import random

sem = Semaphore(3)             # 并發(fā)執(zhí)行數(shù)設(shè)置為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 + " 運行結(jié)束，釋放鎖")
    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()