스레드 간 리소스 공유와 Python 멀티스레딩에서 일반적으로 사용되는 잠금 메커니즘에 대한 소개

이 기사에서는 스레드 간 리소스 공유와 Python 멀티스레딩에서 일반적으로 사용되는 잠금 메커니즘에 대해 소개합니다. 도움이 필요한 친구들이 참고할 수 있기를 바랍니다.

이 기사에서는 스레드 간 리소스 공유와 멀티 스레드 프로그래밍에서 일반적으로 사용되는 잠금 메커니즘을 간략하게 소개합니다.

멀티 스레드 프로그래밍에서는 스레드 간 리소스 공유가 자주 사용됩니다. 일반적으로 사용되는 리소스 공유 방법은 다음과 같습니다.

• 전역 변수(전역)

• 큐(큐 가져오기 대기열에서)

일반적으로 사용됩니다. 리소스 공유 잠금 메커니즘:

• Lock

• RLock

• Semphore

• Condition

(1) 스레드 간 리소스 공유는 다음과 같습니다. 공유, 키워드 글로벌 구현

1. 코드 데모:

from threading import Thread, Lock
lock = Lock()
total = 0

'''如果不使用lock那么，最后得到的数字不一定为0；同时loack不支持连续多次acquire，如果这样做了的后果是死锁！'''
def add():
    global total
    global lock
    for i in range(1000000):
        lock.acquire()
        total += 1
        lock.release()
    
def sub():
    global total
    global lock
    for i in range(1000000):
        lock.acquire()
        total -= 1
        lock.release()
    
thread1 = Thread(target=add)
thread2 = Thread(target=sub)


# 将Thread1和2设置为守护线程，主线程完成时，子线程也一起结束
# thread1.setDaemon(True)
# thread1.setDaemon(True)

# 启动线程
thread1.start()
thread2.start()

# 阻塞，等待线程1和2完成，如果不使用join，那么主线程完成后，子线程也会自动关闭。
thread1.join()
thread2.join()

total

큐를 사용하여 리소스를 공유하세요. 큐는 스레드로부터 안전합니다.

1. from threading import Thread, Lock
   from queue import Queue
   
   def add(q):
       if q.not_full:
           q.put(1)
       
   def sub(q):
       if q.not_empty:
           recv = q.get()
           print(recv)
           q.task_done()
           
   if __name__ =='__main__':
       # 设置q最多接收3个任务,Queue是线程安全的，所以不需要Lock
       qu = Queue(3)
       thread1 = Thread(target=add, args=(qu,))
       thread2 = Thread(target=sub, args=(qu,))
       thread1.start()
       thread2.start()
       # q队列堵塞，等待所有任务都被处理完。
       qu.join()

   (2) 잠금(Lock/RLock/Condition/Semphore)

Lock

1. Lock은 지속적으로 잠금을 획득할 수 없습니다. 그렇지 않으면 잠금 리소스 경쟁으로 인해 교착 상태가 발생할 수 있습니다.

잠금으로 인해 성능이 저하됩니다.

from threading import Thread, Lock
lock = Lock()
total = 0

'''如果不使用lock那么，最后得到的数字不一定为0；同时lock不支持连续多次acquire，如果这样做了的后果是死锁！'''
def add():
    global total
    global lock
    for i in range(1000000):
        lock.acquire()
        total += 1
        lock.release()
    
def sub():
    global total
    global lock
    for i in range(1000000):
        lock.acquire()
        total -= 1
        lock.release()
    
thread1 = Thread(target=add)
thread2 = Thread(target=sub)

# 将Thread1和2设置为守护线程，主线程完成时，子线程也一起结束
# thread1.setDaemon(True)
# thread1.setDaemon(True)

# 启动线程
thread1.start()
thread2.start()

# 阻塞，等待线程1和2完成，如果不使用join，那么主线程完成后，子线程也会自动关闭。
thread1.join()
thread2.join()
total

RLock

1. RLock은 지속적으로 잠금을 획득할 수 있지만 잠금을 해제하려면 해당 개수의 릴리스가 필요합니다

연속적으로 잠금을 획득할 수 있으므로 함수 내에서 잠긴 함수 호출이 가능합니다.

from threading import Thread, Lock, RLock
lock = RLock()
total = 0
def add():
    global lock
    global total
    # RLock实现连续获取锁，但是需要相应数量的release来释放资源
    for i in range(1000000):
        lock.acquire()
        lock.acquire()
        total += 1
        lock.release()
        lock.release()
def sub():
    global lock
    global total
    for i in range(1000000):
        lock.acquire()
        total -= 1
        lock.release()
thread1 = Thread(target=add)
thread2 = Thread(target=sub)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
total

조건 조건 변수

1. 조건 조건 변수는 컨텍스트 관리 프로토콜을 따릅니다. with 문을 사용하여 둘러싸는 블록 기간 동안 관련 잠금을 얻습니다.

wait() 메서드는 잠금을 해제한 다음 다른 스레드가 inform() 또는 inform_all()을 호출하여 잠금을 깨울 때까지 차단합니다. 일단 깨어나면 wait()는 잠금을 다시 획득하고 반환합니다. 시간 초과를 지정할 수도 있습니다.

먼저 차단 대기 상태에서 신호를 받기 위해 대기 함수를 시작한 다음, 신호를 보내기 위해 알림 함수를 시작합니다

from threading import Thread, Condition
'''聊天
    Peaple1 : How are you?
    Peaple2 : I`m fine, thank you!
    
    Peaple1 : What`s your job?
    Peaple2 : My job is teacher.
    
'''

def Peaple1(condition):
    with condition:
        print('Peaple1 : ', 'How are you?')
        condition.notify()
        condition.wait()
        
        print('Peaple1 : ', 'What`s your job?')
        condition.notify()
        condition.wait()

def Peaple2(condition):
    with condition:
        condition.wait()
        print('Peaple2 : ', 'I`m fine, thank you!')
        condition.notify()
        
        condition.wait()
        print('Peaple2 : ', 'My job is teacher.')
        condition.notify()


if __name__ == '__main__':
    cond = Condition()
    thread1 = Thread(target=Peaple1, args=(cond,))
    thread2 = Thread(target=Peaple2, args=(cond,))
    
    # 此处thread2要比thread1提前启动，因为notify必须要有wait接收；如果先启动thread1,没有wait接收notify信号，那么将会死锁。
    thread2.start()
    thread1.start()

#     thread1.join()
#     thread2.join()

Semphore

1. 이 클래스는 세마포 객체를 구현합니다. 세마포어는 release() 호출 수에서 acquire() 호출 수를 뺀 값에 초기 값을 더한 값을 나타내는 원자 카운터를 관리합니다. 필요한 경우 acquire() 메서드는 카운터를 음수로 만들지 않고 반환될 수 있을 때까지 차단됩니다. 지정하지 않으면 기본값은 1입니다.

   #Semaphore 是用于控制进入数量的锁
   #文件， 读、写， 写一般只是用于一个线程写，读可以允许有多个
   
   import threading
   import time
   
   class HtmlSpider(threading.Thread):
       def __init__(self, url, sem):
           super().__init__()
           self.url = url
           self.sem = sem
   
       def run(self):
           time.sleep(2)
           print("Download {html} success\n".format(html=self.url))
           self.sem.release()
   
   class UrlProducer(threading.Thread):
       def __init__(self, sem):
           super().__init__()
           self.sem = sem
   
       def run(self):
           for i in range(20):
               self.sem.acquire()
               html_thread = HtmlSpider("https://www.baidu.com/{}".format(i), self.sem)
               html_thread.start()
   
   if __name__ == "__main__":
       # 控制锁的数量, 每次同时会有3个线程获得锁，然后输出
       sem = threading.Semaphore(3)
       url_producer = UrlProducer(sem)
       url_producer.start()

   (3) 다중 프로세스 프로그래밍에 대한 간략한 소개

   다중 프로세스 프로그래밍에서는 전역 변수를 프로세스 간에 공유하거나 큐에 넣을 수 없습니다.큐를 사용할 수 없습니다.

   1. 다중 프로세스 프로그래밍 통신에는 다음이 필요합니다. 큐, 파이프 사용

   2. 프로세스 풀 프로세스 프로그래밍을 사용하는 경우 통신을 위해서는 Manger 인스턴스의 큐를 사용해야 합니다

   위 내용은 스레드 간 리소스 공유와 Python 멀티스레딩에서 일반적으로 사용되는 잠금 메커니즘에 대한 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!