Python 개발 - 프로세스, 스레드 및 코루틴에 대한 자세한 설명

프로세스란 무엇인가요?

프로그램은 단독으로 실행될 수 없습니다. 프로그램이 메모리에 로드되고 시스템이 리소스를 할당할 때만 실행될 수 있습니다. 프로그램과 프로세스의 차이점은 프로그램은 프로세스의 정적 설명 텍스트인 명령 모음이고 프로세스는 프로그램의 실행 활동이며 동적 개념이라는 것입니다.

스레드란 무엇인가요?

스레드는 운영체제가 작업 스케줄링을 수행할 수 있는 가장 작은 단위입니다. 프로세스에 포함되며 프로세스에서 실제 작동하는 단위입니다. 스레드는 프로세스의 단일 순차적 제어 흐름을 의미하며 여러 스레드가 프로세스에서 동시에 실행될 수 있으며 각 스레드는 서로 다른 작업을 병렬로 수행합니다.

프로세스와 스레드의 차이점은 무엇인가요?

스레드는 메모리 공간을 공유하며 프로세스의 메모리는 독립적입니다.

동일 프로세스의 스레드는 서로 직접 통신할 수 있지만 두 프로세스는 중간 에이전트를 통해 서로 통신해야 합니다.

새 스레드를 만드는 것은 매우 간단합니다. 새 프로세스를 만들려면 상위 프로세스를 복제해야 합니다.

스레드는 동일한 프로세스의 다른 스레드를 제어하고 작동할 수 있지만 프로세스는 하위 프로세스만 작동할 수 있습니다.

Python GIL (Global Interpreter Lock)

열린 스레드 수와 CPU 수에 관계없이 Python은 실행 시 동시에 하나의 스레드만 허용합니다.

Python 스레딩 모듈

직접 호출

1. import threading, time
3. def run_num(num):
4. """
5. 정의 스레드에 의해 실행되는 함수
6. :param num:
7. :return:
8. """
9. print("실행 중 번호:% s"%num)
10. time.sleep(3)
12. if __name__ == '__main__':
13. ​ # 생성 스레드 인스턴스 t1
14. t1 = threading.Thread(target=run_num,args=(1,))
15. # 스레드 인스턴스 생성 t2
16. t2 = threading.Th read(target=run_num ,args=(2,))
17. ​​​​ # 스레드 시작 t1
18. ​​ t1.start()
19. ​​ # 시작 스레드 t2
20. t2.start()
21.                                                                                                  # 스레드 이름을 가져옵니다. >
    실행 번호: 1
22. 실행 번호: 2
23. 가져오기 스레딩, 시간
24. ​​​​)
25.      self.num = num
26. # 각 스레드에서 실행할 함수를 정의합니다. 함수 이름은 run
27. 이어야 합니다. :
28. print("실행 중인 번호: %s
    "%self.num)
29. time.sleep(3)
31. if __name__ == '__main__':
32. t1 = MyThread(1)
33. t2 = MyThread(2)
34. t1.start()
35. t2.start ()
36. 출력:
37. running on number:1
38. running on number:2
39. Join and Daemon Join
Join의 기능은 메인 프로세스를 차단하고 조인 후 프로그램을 실행할 수 없습니다.
40. 멀티 스레드 및 다중 조인의 경우 각 스레드의 조인 메서드가 순차적으로 실행되며, 다음 스레드가 실행되기 전에 이전 스레드의 실행이 완료됩니다. 매개변수가 없으면 후속 프로그램을 실행하기 전에 스레드가 끝날 때까지 기다리세요.
매개변수를 설정한 후 스레드가 설정한 시간 동안 기다린 후 스레드 종료 여부에 관계없이 후속 메인 프로세스를 실행합니다.
41. 가져오기 스레딩, 시간

class

MyThread(threading.Thread):
1.     self,num):
2. .Thread.__init__ (self)
3. ​​​​​​self.num = num
4. ​​​​ (self) :
5.                                                                  ​ ​​print("thread:% s
   "%self.num)
7. if
   __name__ == '__main__':
8. t1 = MyThread(1)
9. t2 = MyThread( 2 )
10. t1.start()
11. t1.join()
12. t2.start()
13. t2.join()
14. 출력:
15. 실행 번호: 1
16. 스레드:1
17. running on number:2
18. thread:2

매개변수 설정의 효과는 다음과 같습니다.

1. if __name__ == '__main__':
2. t1 = MyThread(1)
3. t2 = MyThread(2)
4. t1.start()
5. t1.join(2)
6. t2.start( )
7. t2.join()
8. 출력:
9. running on number:1
10. running 번호:2
11. thread: 1
12. thread:2

Daemon

기본적으로 메인 스레드는 종료 시 모든 하위 스레드가 끝날 때까지 기다립니다. 메인 스레드가 하위 스레드를 기다리지 않고 종료 시 모든 하위 스레드를 자동으로 종료하도록 하려면 하위 스레드를 백그라운드 스레드(데몬)로 설정해야 합니다. 메소드는 스레드 클래스의 setDaemon() 메소드를 호출하는 것입니다.

1. 가져오기 시간,스레딩
3. def run(n):
4. ​​​​print("%s".center(20," *") %n)
5. time.sleep(2)
6. print("done".center(20,"*"))
8. def main():
9. for i in range(5):
10. t = threading.Thread(target=run,args=(i,))
11. t.start()
12. t.join(1)
13. print("시작 스레드",t.getName())
15. m = threading.Thread(target=main,args=())
16. # 메인 스레드를 프로그램의 메인 스레드의 데몬 스레드 역할을 하는 데몬 스레드로 설정합니다. 메인 스레드가 종료되면 m 스레드도 종료됩니다. 실행 완료 여부에 관계없이 m이 시작한 다른 하위 스레드도 동시에 종료됩니다. m.start()
17. m.join(3)
18. print("main thread done".center(20,"*"))
19. 출력:
20. *********0**********
21. 스레드 시작 Thread-2
22. ************ 1*** ******
23. **********완료************
24. 스레드 시작 Thread-3
25. **** *****2**********
26. **메인 스레드 완료**

스레드 잠금(Mutex)

One 프로세스는 여러 스레드를 시작할 수 있으며, 여러 스레드는 상위 프로세스의 메모리 공간을 공유합니다. 이는 각 스레드가 동일한 데이터에 액세스할 수 있음을 의미합니다. 이때 두 스레드가 동시에 동일한 데이터를 수정하려는 경우 스레드 잠금이 수행됩니다. 필수의.

1. import time,threading
3. def addNum():
4. ​​ # 각 스레드에서 이 전역 변수를 가져옵니다
5.  전역 번호​ ​​​
6. num -= 1
7. # 공유 변수 설정
8. num = 100
9. thread_list = []
10. for i in
    범위(100):
11. t = threading.Thread(target=addNum)
12. t.start()
13. thread_list.append( t)
14. # 모든 ​​스레드의 실행이 완료될 때까지 기다립니다.
15. for t in
    thread_list:
16. t.join()
18. 인쇄 ("최종 숫자:" ,num)
잠긴 버전
19. Lock은 다른 스레드가 공유 리소스에 액세스하는 것을 차단하며 동일한 스레드는 한 번만 획득할 수 있습니다. 프로그램을 계속 실행할 수 없습니다.
20. import time,threading
21. def addNum():
​​ # 각 스레드에서 이 전역 변수를 가져옵니다
1.  전역 숫자
3. print("
   --get num:",num)
4. time.sleep(1)
5. ​ # 데이터 수정 전 잠금
6. ​ lock.acquire()
7. ​ # 이 공용 변수에 대해 -1 연산을 수행합니다
8. 숫자 -= 1
   ​​​​100
9. thread_list = [ ]
10. # 전역 잠금 생성
11. lock
    = threading.Lock()
for
13. i
    in 범위(100):
14. t = threading.Thread(target=addNum)
15. t.start()
16. (티)
    # 모든 ​​스레드가 완료될 때까지 기다리세요
17. for
    t
in
18. thread_list:
19. t.join()
20. 인쇄( "
final num:
21. ",num)
    GIL VS LockGIL은 동시에 하나의 스레드만 실행할 수 있도록 보장합니다. 잠금은 사용자 수준 잠금이며 GIL과 관련이 없습니다.
22. RLock(재귀 잠금)
    Rlock을 사용하면 동일한 스레드에서 여러 번 획득할 수 있습니다. 스레드가 공유 리소스를 해제하려면 모든 잠금을 해제해야 합니다. 즉, n번의 획득에는 n번의 해제가 필요합니다.
def run1():
24. print("
    첫 번째 부분 데이터 가져오기
")

lock

.acquire()
1.  전역 숫자
   ㅋㅋㅋ
2. def run2():
     print("
두 번째 부분 데이터 가져오기
3. ")
    
lock
4. .acquire()
5.  global num2
6. 숫자2 += 1
lock
7. .release()
return
8. num2
10. def run3():
11.     lock.acquire()
12.     res = run1()
13.     print("run1과 run2".center(50,"*"))
14.     res2 = run2()
15.     lock.release()
16.     인쇄(res,res2 )
18. if __name__ == '__main__':
19.     num,num2 = 0,0
20.     lock = threading.RLock()
21.     for i in 범위(10):
22.        t = threading.Thread(target=run3)
23.         t.start()
25. while threading.active_count() != 1:
26.     print(threading.active_count())
27. else:
28.     인쇄(" 모든 스레드 완료".center(50,"*"))
29.     print(num,num2)

这两种锁的主要区别是线程中被多次acquire.而Lock却不允许这种情况。注意，如果使用RLock，那么acquireandrelease必须成对了n次acquire，必须调用n次的release才能真正释放所?锁。

세마포어(信号weight)

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数weight线程更改数敍，比如售票处는 3个窗口,那最多只允许3个人同时买票,后면的人只能等前面任意窗口的人离开才能买票。

1. import threading,time
3. def run(n):
4.     semaphore.acquire( )
5.     time.sleep(1)
6.     print("스레드 실행:%s"%n)
7.     semaphore.release()
9. if __name__ == '__main__':
10.     # 最多允许5个线程同时运行
11.     세마포어 = threading.BoundedSemaphore(5)
12.      for i in 범위(20):
13. t = threading.Thread(target=run,args=(i,))
14. t.start()
16. while 카운트() != 1:
17. ​​ # print(threading.active_count())
18. ​​ pass
19. else:
20. print(" all thread done ".center(50,"*"))

Timer(타이머)

Timer는 일정한 간격으로 함수를 호출합니다. 일정한 간격으로 함수를 호출하려면 다음을 호출해야 합니다. 타이머 기능에서 타이머를 다시 설정하세요. 타이머는 Thread의 파생 클래스입니다.

1. import threading
3. def hello():
4. print("hello, world!")
5. # 5초 후 지연 Hello 함수 실행
6. t = threading.Timer(5,hello)
7. t.start()

Event

Python은 스레드 간 통신을 위한 Event 객체를 제공합니다. 스레드에 의해 설정된 신호 플래그입니다. 신호 플래그 비트가 거짓이면 스레드는 다른 스레드에 의해 명령 신호가 참으로 설정될 때까지 기다립니다. Event 개체는 스레드 간의 통신을 실현하기 위한 간단한 스레드 통신 메커니즘을 구현합니다.

1. 신호 설정

Event의 set() 메서드를 사용하여 Event 개체 내부의 신호 플래그를 true로 설정합니다. Event 객체는 내부 신호 플래그의 상태를 결정하기 위해 isSet() 메서드를 제공합니다. 이벤트 객체의 set() 메서드가 사용되면 isSet() 메서드는 true를 반환합니다.

1. Clear the signal

Event객체 내부의 signal flag를 클리어하려면 Event의clear()메소드를 사용합니다. 즉, Event의clear()메소드를 사용하면 isSet이 됩니다. () 메서드는 false를 반환합니다.

1. Waiting

Event의 wait() 메서드는 내부 신호가 true인 경우에만 빠르게 반환을 실행하고 완료합니다. Event 객체의 내부 신호 플래그가 false인 경우 wait() 메서드는 반환하기 전에 해당 플래그가 true가 될 때까지 기다립니다.

이벤트를 사용하여 두 개 이상의 스레드 간의 상호 작용을 구현해 보겠습니다. 즉, 신호등 역할을 하는 스레드를 시작하고 차량 역할을 하는 여러 스레드를 생성하면 차량이 그에 따라 주행합니다. 빨간색 정지와 녹색 규칙으로 이동하세요.

1. import 스레딩,시간,random
3. def light():
4. if 이벤트 . isSet():
5. ​​​​if 개수 < 5:
6. 인쇄("
7.         elif 개수 < 8:
8.             print(" 33[43;1m--노란색 표시등 켜짐-- 33[0m".center(50,"*"))
9.         elif 개수 < ; 13:
10.             ifevent.isSet():
11.               event()
12.             print(" 33[41;1m--red 불 켜기-- 33[0m".center(50,"*"))
13.         else:
14.             개수 = 0
15.             이벤트. set()
16.         time.sleep(1)
17.        count += 1
20. def car(n):
21.     while 1:
22.         time.sleep(random.randrange(10))
23.         if event.isSet():
24.             인쇄( "%s 자동차가 달리고 있습니다..."%n)
25.         else:
26.             print(" %s 자동차가 빨간불을 기다리고 있습니다..."% n)
28. if __name__ == "__main__":
29.     event = threading.Event()
30.     빛 = 스레딩.스레드 (대상=빛,)
31.     Light.start()
33.     for i in 범위(3):
34.         t = 스레딩.스레드 (target=car,args=(i,))
35.         t.start()

queue queue

Python의 대기열은 스레드 간 데이터 교환에 가장 일반적으로 사용되는 형식입니다. Queue 모듈은 Queue 작업을 제공하는 모듈입니다.

큐 객체 생성

1. import queue
3. q = queue.Queue(maxsize = 10)

queue.Queue 클래스는 큐 동기화 실현입니다. 대기열 길이는 무제한이거나 제한될 수 있습니다. 큐 길이는 Queue 생성자의 선택적 매개변수 maxsize를 통해 설정할 수 있습니다. maxsize가 1보다 작으면 대기열 길이는 무제한입니다.

큐에 값을 넣습니다

1. q.put("a")

큐 객체의 put() 메서드를 호출하여 큐 끝에 항목을 삽입합니다. put()에는 두 개의 매개변수가 있습니다. 첫 번째 항목은 삽입된 항목의 값이며 두 번째 블록은 선택적 매개변수이며 기본값은 1입니다. 대기열이 현재 비어 있고 블록이 1인 경우 put() 메서드는 데이터 단위가 해제될 때까지 호출 스레드를 일시 중지합니다. block이 0이면 put() 메서드는 Full 예외를 발생시킵니다.

큐에서 값 제거

1. q.get()

큐 객체의 get() 메서드를 호출하여 큐의 헤드에서 항목을 삭제하고 반환합니다. 선택적 매개변수는 block이며 기본값은 True입니다. 대기열이 비어 있고 block이 True인 경우 get()은 항목을 사용할 수 있을 때까지 호출 스레드를 일시 중지합니다. 큐가 비어 있고 블록이 False인 경우 큐는 비어 있음 예외를 발생시킵니다.

Python 대기열 모듈에는 세 개의 대기열과 생성자가 있습니다

1. # 선입선출
2. class queue.Queue(maxsize=0)
3. # 선입선출
4. class queue.LifoQueue(maxsize=0)
5. # 우선순위 큐 레벨이 낮을수록 먼저 나옵니다
6. class queue.Priority 대기열(최대 크기 =0)

Commonmethods

1. q = queue.Queue()
2. # 대기열의 크기를 반환합니다
3. q.qsize()
4. # 대기열이 비어 있으면 True를 반환하고 그렇지 않으면 False를 반환합니다
5. q.empty()
6. # 대기열이 가득 차면 True를 반환하고 그렇지 않으면 False를 반환합니다
7. q .full()
8. # 대기열 가져오기, 대기 시간 제한 시간
9. q.get([block[,timeout]])
10. # q.과 동일 get(False)
11. q.get_nowait()
12. # 다른 작업을 수행하기 전에 대기열이 빌 때까지 기다리세요
13. q.join()

생산자-소비자 모델

개발 및 프로그래밍에서 생산자와 소비자 패턴을 사용하면 대부분의 동시성 문제를 해결할 수 있습니다. 이 모드는 프로덕션 스레드와 소비자 스레드의 작업 성능 균형을 유지하여 프로그램의 전반적인 데이터 처리 속도를 향상시킵니다.

생산자와 소비자 모델을 사용하는 이유

스레드 세계에서 생산자는 데이터를 생성하는 스레드이고 소비자는 데이터를 소비하는 스레드입니다. 멀티 스레드 개발에서 생산자의 처리 속도가 매우 빠르고 소비자의 처리 속도가 매우 느린 경우 생산자는 데이터 생성을 계속하기 전에 소비자가 처리를 마칠 때까지 기다려야 합니다. 마찬가지로 소비자의 처리 능력이 생산자의 처리 능력보다 크면 소비자는 생산자를 기다려야 합니다. 이러한 문제를 해결하기 위해 생산자 모델과 소비자 모델이 등장했습니다.

생산자-소비자 패턴이란 무엇인가요?

생산자-소비자 패턴은 컨테이너를 사용하여 생산자와 소비자 간의 강력한 결합 문제를 해결합니다. 생산자와 소비자는 서로 직접 통신하지 않고 차단 대기열을 통해 통신하므로 생산자가 데이터를 생성한 후 더 이상 소비자가 이를 처리할 때까지 기다리지 않고 소비자가 직접 차단 대기열에 넣습니다. 생산자에게 데이터를 요청하지만 차단 대기열에서 직접 가져옵니다. 차단 대기열은 생산자와 소비자의 처리 기능의 균형을 맞추는 버퍼와 동일합니다.

생산자-소비자 모델의 가장 기본적인 예입니다.

1. import queue,threading,time
3. q = queue.Queue(maxsize=10)
5. def 프로듀서():
6. Count = 1
7. while True:
8. q.put("bone %s"%count)
9. print(" 생산된 뼈 " ,count)
10. count += 1
12. def 소비자(이름):
13. 동안 q.qsize() >
    인쇄 ("%[%s]가 [%s]을(를) 얻어서 먹어요...
"%(name, q.
14. get
    ())) time.sleep ( 1)
16. p = threading.Thread(target=Producer,)
17. c1 = threading.Thread(target=Consumer,args=("
    번영
",) )
18. c2 = threading.Thread(target=Consumer,args=("
    来福
",))
19. p.start()
20. c1.start( )
21. c2.start()