스레딩 모듈 방법을 이용하여 스레드 열기

하나 명 이상의 스레드의 개념을 소개
스레딩 모듈을 소개합니다
스레딩 및 사용 모듈 수준의 모듈을 멀티 프로세싱을 유사점이 많이있다.
둘째, 두 가지 방법으로 열려있는 멀티 스레드
스레드 오버 헤드를 만들기 1. 덜 따라서 빠르게 쓰레드를 생성, 생성 과정의 비용보다
가져 오기 프로세스 멀티 프로세싱
스레드 스레딩 가져 오기에서
가져 오기 운영 체제
가져 오기 시간
: DEF 일 ()
인쇄 ( '<%를 S> 실행하는 'os.getpid %를 ())
time.sleep (2)
인쇄 ('<S %> 완료 'os.getpid % ())
IF 이름 ==' 주 ':
T = 스레드 (목표 = 작업 ,)

t = 프로세스 (목표 = 일)

t.start()
print('主',os.getpid())

과정을 여는 첫 번째 방법
스레드에서 스레딩 가져 오기
가져 오기 시간
클래스 작업 (스레드)를 :
DEF 초기화 (자기 이름) :
슈퍼 (). 초기화 ()
self.name 이름 =
DEF RUN (자기) :

time.sleep (2)

    print('%s say hell'%self.name)

IF 이름 == ' 주 '
T = 일 ( '에곤')
t.start ()는
( '주')를 인쇄
(클래스) 스레드의 제 2 실시 예를 여는
과정에서 프로세스와 스레드 복수 개방 서브 - 프로세스의 복수의 개구부의 차이
오기 다중 처리 과정에서
스레드 스레딩 오기로부터
가져 시간
DEF 작업 ()
time.sleep (2)
인쇄 ( '안녕하세요')
IF 이름 == ' 주 ':
T = 스레드 (목표 = 작업) 몇 초를 기다리면 #, 그는 동일하지 않은 경우에하는 첫 인사 인쇄됩니다, 주요 인쇄 과정에서 처음으로 열립니다

t = 프로세스 (대상 = 작업) # 자식 프로세스는 첫째, 마스터 인쇄됩니다

t.start()
print('主')

속도 열기 스레드 프로세스의 개방 속도보다 크다

2 .----------

에서 멀티 가져 오기 프로세스
스레드 스레딩 가져 오기에서
가져 오기 운영 체제
DEF 일 () :
인쇄 ( '헬로', os.getpid ())
IF 이름 == ' 주 '
각 스레드에 관련된 주요 공정에서 열린 여러 스레드에 # PID의 주 공정으로서
T1 = 스레드 (목표 = 작업)
T2 = 스레드 (목표 = 작업)
t1.start ()
t2.start ()
인쇄 ( "메인 쓰레드 PID 'os.getpid ())

#来多个进程，每个进程都有不同的pid
p1 = Process(target=work)
p2 = Process(target=work)
p1.start()
p2.start()
print('主进程pid', os.getpid())

복수의 프로세스와 스레드의 복수 PID 개구 동일한 프로세스 상이한하에 여는
스레드에서 스레딩 가져
오기 프로세스 멀티 프로세싱
오기 OS
: DEF 일 ()을
글로벌 N-
N- = 1.
# 99이므로 그 변경된 인쇄 (N-)
= 100 N-
IF 이름 == ' 주요 '

p = 프로세스 (목표 = 일)

p = Thread(target=work)  #当开启的是线程的时候，因为同一进程内的线程之间共享进程内的数据
                        #所以打印的n为99
p.start()
p.join()
print('主',n) #毫无疑问子进程p已经将自己的全局的n改成了0,
# 但改的仅仅是它自己的,查看父进程的n仍然为100

동일한 프로세스에서 프로세스의 스레드 데이터를 공유
프로세스 사이는 서로 격리와 공유하지 않습니다 있습니다. 우리는 주를 완료하기 위해 제 3자를 사용해야합니다 (큐에 의해, 파이프, 공유 데이터)

셋째, 운동

연습 1 : 멀티 스레드 동시성

소켓 수입에서
수입 스레드 스레딩에서
의 = 소켓 (AF_INET, SOCK_STREAM)
s.setsockopt (SOL_SOCKET, SO_REUSEADDR, 1) #端口重用
s.bind (( '127.0.0.1', 8081))
s.listen (5)
인쇄 ( '실행 시작 ...')
DEF 이야기 (검둥이, ADDR을) :
#通信循环: 진정한 동안
: 시도
cmd를 = coon.recv (1024)
) 인쇄 (cmd.decode ( 'UTF-8')
cmd를하지 않을 경우 : 휴식
coon.send (cmd.upper ())
프린트 (. '发送的是% S'% cmd.upper () 디코딩 ( "UTF-8"))
의 예외를 제외 :
브레이크
coon.close ()
만약 이름 '== 메인 '
동안 진정한 #链接循环
너구리, ADDR = s.accept ()
인쇄 (검둥이, ADDR)
P = 스레드 (대상 = 이야기, 인수 = (검둥이,ADDR))
p.start ()
S.CLOSE ()
서버
소켓 오기에서
C = 소켓 (AF_INET, SOCK_STREAM)
c.connect (( '127.0.0.1', 8081))
진정한 동안 :
cmd를 INPUT = ( '>>') .strip ()
하지 않음 cmd를 경우 : 계속
( '. UTF-8'cmd.encode ()) c.send를
데이터 = c.recv (1024)
인쇄 ( '접수 %의'% data.decode ( 'UTF -8 '))
c.close ()
클라이언트
운동 II는 : 세 가지 작업은, 사용자 입력, 대문자 형식으로 사용자의 입력 내용을 수신하는 결과는 파일로 포맷

반입 실 스레딩에서
수입 OS
input_l = []
format_l = []
#监听输入任务: DEF 토크 ()
진정한 동안 :
cmd를 = 입력 ( '>>'). 스트립 ()
cmd를하지 않을 경우 : 계속
input_l.append (cmd를 )

형식 DEF () :
: 진정한 동안
input_l 경우 :
RES = input_l.pop () # 꺼낸
format_l.append를 대문자가 변형 후 (res.upper는 ()) # 꺼낸
: DEF 저장 ()
그동안 참가 :
# 경우 : format_l IF format_l 버리지
열기 ( 'DB', 'A')로 F로 :
f.write (format_l.pop을 () + '\ N-') 파일 번호의에 기록
f.flush ()
IF 이름 == ' 주요 '
스레드 = T1 (대상 = 토크)
T2 = 스레드 (대상 = 형식)
T3 = 스레드 (저장 대상 =)
t1.start ()
t2.start ()
t3.start ()
답
동일한 프로세스의 주 내에서 네 개의 다중 스레드를 주소 공간
함수 () {// MT4 학습 : www.kaifx.cn/mt4.html
스레드 스레딩 오기로부터
임포트 처리 멀티 프로세싱
오기 OS
N-100 =을
토크 DEF () :
글로벌 N-
N- 100 =
인쇄 (N-)
IF 이름 == ' 주 ':
T = 스레드 (대상 = 토크) 스레드가 다음 켜져있는 경우 # N = 0

t = 프로세스 (= 목표 토크) # 다음, 프로세스는, 열려있는 경우, N = 100

t.start()
t.join()
print('主',n)

다섯 개 다른 스레드 객체의 속성과 메소드

방법 스레드 객체 인스턴스

으로 isAlive () : 반환 스레드가 활성화됩니다.

getName은 () : 스레드의 이름을 돌려줍니다.

에서는 setName () : 스레드의 이름을 설정합니다.

스레딩 모듈이 제공하는 몇 가지 방법 :

threading.currentThread는 () : 현재 스레드 변수를 돌려줍니다.

threading.enumerate는 () : 실행되는 쓰레드의리스트를 돌려줍니다. 실행 스레드의 시작을 의미,이 끝나기 전에, 시작하기 전에 및 종료 후 스레드가 포함되어 있지 않습니다.

threading.activeCount는 () : 실행 스레드의 수를 돌려줍니다 렌 (threading.enumerate ()) 같은 결과가 있습니다.

수입 스레드 스레딩에서
가져 오기 프로세스의 멀티 프로세싱에서
, 운영 체제를 가져 오기 시간을 스레딩
데프 일 () :
time.sleep을 (2)
인쇄 (. % threading.currentThread () getName () %의 실행 중입니다 ')
(인쇄 (threading.current_thread를 )) #其他线程
인쇄 (threading.currentThread () getName ()) #得到其他线程的名字.
만약 이름 == ' 주 '
t = 스레드 (목표 = 일)
t.start ()

print(threading.current_thread().getName())  #主线程的名字
print(threading.current_thread()) #主线程
print(threading.enumerate()) #连同主线程在内有两个运行的线程
time.sleep(2)
print(t.is_alive()) #判断线程是否存活
print(threading.activeCount())
print('主')

다른 속성 및 스레드의 방법
여섯, 데몬 스레드에 가입

이러한 그의 (자원의 회복 하위 프로세스) :( 부모 - 자식 관계)의 말과 같은 과정이 끝나기 전에 자식 프로세스의 모든 기본이 아닌 보호자
(NO 부모 - 자식 관계) : 모든 종료를 종료 메인 스레드 및 기타 비 데몬 스레드

에서 스레드 오기 스레딩
오기 시간 OS
DEF 토크 ()
. (3) time.sleep
인쇄 ( "%의 S가 실행된다 .. 'os.getpid %를 ())
IF 이름 '== 메인 ':
T = 스레드 (목표 = 토크)
t.start ()
자식 프로세스 t.join () 등의 말과 같은 # 주요 프로세스
인쇄 ( '주')

가입
스레드와 데몬 데몬 차이를

1. 데몬 : 모든 비 데몬 프로세스의 끝, 데몬을 파괴 할 때까지의 주요 과정을 기다립니다. 그 (제거합니다 가드를 통해 실행 주 과정)

2. 데몬 스레드 : 메인 스레드는 아직 모두 종료 종료 수호 죽, 메인 스레드 및 기타 비 데몬 스레드를 완료하지 않았 음을 실행

가져 오기 프로세스 멀티 프로세싱에서
스레딩 수입 스레드, currentThread의에서
수입 시간, OS
: DEF talk1 ()
time.sleep (2)
인쇄 ( '안녕하세요')
DEF talk2 () :
time.sleep (2)
인쇄 ( '당신이 볼 참조')
만약 이름 == ' 주 '
T1 = 스레드 (목표 = talk1)
T2 = 스레드 (목표 = talk2)

T1 = 프로세스 (목표 = talk1)

# t2 = Process(target=talk2)
t1.daemon = True
t1.start()
t2.start()
print('主线程',os.getpid())

데몬과 데몬 스레드
예 # 3 -------- 사람들을 혼란
스레드에서 스레딩 가져 오기
가져 오기 시간
DEF foo는 () :
인쇄 (123)

time.sleep (10) # 등 다음보다 시간이 더는 같이, 인쇄 end123을 넣어하지 않는 경우

time.sleep(2)  #如果这个等的时间小于下面等的时间，就把end123也打印了
print('end123')

데프 바 () :
인쇄 (456)

time.sleep (5)

time.sleep(10)
print('end456')

IF 이름 == ' 주 ':
T1 = 스레드 (대상 = foo는)
T2 = 스레드 (대상 = 바)
t1.daemon # = 진정한 메인 쓰레드가 없습니다 완성 된 살인을 가지고 데몬 실행,

주 스레드 및 기타 비 데몬 스레드가 모두 종료 종료합니다

t1.start()
t2.start()
print('main---------')

유혹의 예
일곱, GIL 및 잠금

1.python GIL (글로벌 통역 잠금) # 글로벌 통역 잠금

2. 잠금의 목적 : 효율성의 비용, 데이터의 보안을 보장
3. 보호를 더한 다양한 서로 다른 데이터 잠금 ()
자신의 가비지 컬렉션 4.python을

GIL로 잠금하자 누군가가 CPython의 인터프리터를 얻을 수행 할 수있는 권한을 가지고 5

6.GIT 잠금 보호 데이터의 안전한 CPython의 통역이지만, 자신의 데이터 프로그램의 보안 보호하지 않습니다
잠금을 해제하도록 강제 폐쇄에 직면했을 때 7.GIL 잠금을 다음 다른 한편으로는 잠금을 움켜 잡기 시작
수정의 값 후에을하지만, 첫 번째는 여전히 아직 데이터를 얻을 수 있었다 머물 얻기 위해 다시 한 번 걸릴 때,
잠 데이터는 수정, 당신은 또한 얻을되었을 때 우리가 보장 할 수 있도록 원래, 그래서 혼란
데이터의 보안을.
? 데이터 보안 NE를 해결하는 방법 8. 그래서
) (뮤텍스 = 잠금 : 자신은 플러스 잠금 제공합니다

젠록

GIL 및 잠금이 잠금, 데이터의 보호는 자신을 개발하기 위해 데이터 보호 사용자의 응용 프로그램 인 (물론, 이러한 데이터의 가비지 컬렉션과 통역 수준의 데이터를 보호하는 것입니다) 이전 통역의 수준, 동일하지 않습니다 있습니다 , 단지 것을 사용자 정의 잠금을 처리 할 수 ​​GIL이 문제에 대해 책임을지지 않습니다 분명하다 잠금

프로세스 분석 : 잡아 모든 스레드 GIL 잠금 것을, 나 잡아 모든 스레드 권한을 실행하는

해당 스레드 1은 잠금을 해제하지 않은, 스레드 2가 잡아 GIL 잠금 가능성이 권한, 실행을 실행 얻을, 1 개 잡아 GIL 잠금 스레드, 그리고 소수의 잠금, 아직 완료되지 않았을 추가, 실행의 과정을 시작 잠금 스레드 (1)를 해제 한 후 권한이 박탈되고 실행 차단 입사 2 스레드 발견되지 않은, 상기 스레드 1 GIL를 얻을 수 있고, 그리고 잠금을 해제하기 위해 통상 수행한다. . . 일련 동작의 영향이 리드

이 직렬이기 때문에, 우리는 실행

t1.start ()

t1.join

t2.start ()

t2.join ()

이 잠금 장치를 추가하는 이유 아, 그것이 알고는 T1 실행 코드, 코드 잠금 T1 모두에 해당하는 모든 기다리고 조인 직렬 실행하고, 잠금 코드가 공유 데이터를 잠그는 작업의 일부에 불과합니다.

파이썬 인터프리터는 자동으로 정기적으로 메모리를 복구하는 데 도움이 있기 때문에, 당신은 파이썬 인터프리터가 별도의 스레드를 가지고 이해할 수있는, 모든에 한 번이 취소 될 수있는 메모리 데이터를 확인하기 위해 글로벌 설문 조사에서 일어나 한 반면, 자신의 스레드와 당신이 변수 스레드,이 변수를 비우는 과정에서 스레드 쓰레기 수집 평 통역 청산 순간을 삭제하면 자신의 스레드 통역 평가 동시에 실행의 프로그램이 시점에서, 그것은있을 수 있습니다 단지 메모리 공간을 확보하기 위해 다시 한번 오지 않았다 및 유사한 문제, 파이썬 인터프리터 간단하고 원유를 해결하기 위해, 새로운 데이터가 삭제 된 할당 할 수있는 결과를 할당 된 다른 스레드, A, 즉 잠금 실행 스레드, 다른 사람들이 위의 문제를 해결하는 것, 움직이지 않는, 그것은라고 할 수 파이썬의 이전 버전의 유산.

반입 실, 잠금 나사로부터
반입 시간
N = 100
DEF 일 ()
mutex.acquire ()
전역 n 개의
온도 = N
time.sleep (0.01),
N = 1 임시
mutex.release ()을
경우 이름 == ' 주 '
뮤텍스 잠금 = ()
t_l = []
S =로 time.time ()
전 범위 (100)를 들어
t = 스레드 (목표 = 일)
t_l.append (t)
t.start ()
: t의 t_l 대한
t. ) (가입
인쇄 ( '% S : % S'% (로 time.time () - S, N))

글로벌 통역 잠금
잠금 장치는 일반적으로 공유 리소스에 대한 액세스를 동기화하는 데 사용됩니다. 당신이 잠금 개체를 얻을 수있는 자원, 전화 취득 방법에 액세스해야 할 때 잠금, 각 개체에 공유 리소스를 만들려면 리소스 액세스 끝날 때까지 (다른 스레드가 이미 출시 될 때까지 기다려야하는 잠금, 현재의 thread의 요구를 취득한 경우) 다음 잠금을 해제하기 위해 해제 메소드를 호출

스레딩 오기
threading.Lock과의 뮤텍스 = ()
mutex.aquire ()
'' '
일반적인 데이터 운영
' ''
(mutex.release)

형식 잠금
분석 1 :
권한을 잡아 실행 (22 개) 1.100 잡아 GIL 잠금 스레드
(시간 동안 스레드 1 호출되는) GIL을 잡기 위해 스레드가 있어야합니다 33 2, 및 실행을 시작, 그것은 한 번 실행 얻을 것이다 lock.acquire ()
4 4 3. 스레드 1이 아직 완성 된 실행은 가능성이 높습니다, 거기에 다른 스레드에게 2 잡아 GIL이며, 다음 실행하기 시작하지만, 아직 공개되지 않은 뮤텍스 잠금 실 2 실 1, 다음 차단 된 것을 발견 수행 할 권한 GIL, 즉 박리 넘겨 강제
실행 통상 방출 뮤텍스 잠금까지 최종 정지 위치로부터 계속 5 5 제 1 스레드는 다시 GIL를 잡고까지를 다음 다른 스레드 (234)를 반복 할 물론
잠하지 않는 경우 : 동시 실행 속도와 데이터를 고정합니다.

잠금 : 일련의 실행, 느린 및 데이터 보안.

# 풀린다 : 비보안 동시 실행 속도, 데이터가
스레딩에서 가져 오기가 current_thread 스레드 잠금
오기 OS 시간
DEF 태스크 () :
글로벌 N-
인쇄. ( "실행중인 S % '% current_thread () getName ())
= N-TEMP
time.sleep (0.5)
N - 1 = TEMP.

만약 이름 == ' 주 '
= 100 N
잠금 잠금 = ()
스레드 = []
START_TIME로 time.time = ()
전 범위 (100)를 들어
t = 스레드 (목표 = 태스크)
threads.append (t)
t .start ()
스레드 t에 대한 :
t.join ()

stop_time=time.time()
print('主:%s n:%s' %(stop_time-start_time,n))

''
스레드 1은 실행중인
스레드가 실행되는 2
......
스레드 (100)가 실행된다
: 99 : 0.5216062068939209主N
'' '

# 잠금 해제 : 잠금 해제 동시 실행 부분, 잠금 일부 직렬 실행이 느리고, 데이터 보안
스레딩 가져 오기에서이 스레드, 잠금 current_thread
가져 오기 운영 체제, 시간
DEF 작업 () :
실행 # 잠금 해제 코드를 동시에
시간 .sleep을 (. 3)
인쇄 (current_thread % '실행하려면 % S 시작'(). getName ())
글로벌 N-
# 시리얼 코드 실행 잠금
lock.acquire ()를
TEMP = N-
time.sleep (0.5)
N-TEMP = -1
lock.release ()

만약 이름 == ' 주 '
= 100 N
잠금 잠금 = ()
스레드 = []
START_TIME로 time.time = ()
전 범위 (100)를 들어
t = 스레드 (목표 = 태스크)
threads.append (t)
t .start ()
스레드에 대한 t :
t.join ()
STOP_TIME로 time.time = ()
인쇄 ( '主%의 SN % S'% (STOP_TIME - START_TIME, N))

''
스레드 1은 실행중인
스레드가 실행되는 2
......
스레드 (100)가 실행되는
0 : 53.294203758239746主N
'' '

# 일부 학생들이 질문을 할 수 있습니다 : 잠금이 직렬 실행이 될 것이기 때문에, 나는, 당신은 아, 고정하지 않는이 시작 직후 조인을 사용, 아 효과는 시리얼입니다
# 오른쪽 : 시작 후 즉시 사용 jion는 확실히 작업이 최종 N의 결과가 확실하게 0 안전하지만 문제가하는 것입니다, 의심 할 여지없이, 100 시리얼된다 실행할
작업 내의 모든 코드는 일련 있습니다 #START 후 즉시 가입 실행 및 잠겨 있지만, 일부는 공유 데이터를 수정할 수있는 잠금 섹션은 직렬 인
데이터 보안을 보장하기 위해 하나, 둘 다 달성 할 수에서 #,하지만 잠겨 명확하게 높은 효율이다.
스레딩 가져 오기에서 current_thread, 스레드, 잠금
가져 오기 OS, 시간
DEF 작업 () :
time.sleep (. 3)
인쇄 (. %의 current_thread ( 'RUN %의 S 시작') getName ())
글로벌 N-
TEMP = N-
time.sleep (0.5)
N- 온도 = -1

만약 이름 == ' 주 '
= 100 N
잠금 잠금 = ()
START_TIME로 time.time = ()
영역에서의 I (100) :
t = 스레드 (목표 = 태스크)
t.start ()
t.join ()
STOP_TIME 로 time.time = ()
인쇄 ( '主%의 SN % S'% (STOP_TIME - START_TIME, N))

'' '
스레드 시작 1-RUN.
RUN에 스레드 시작-2
......
RUN-100 스레드 시작에
홈페이지 : 350.6937336921692는 N : 0 # 테러 얼마나 시간이 소요됩니다
' ''
차이와 뮤텍스 가입 (강조!)