프로세스 : 데이터 세트의 개별 기능을 갖는 프로그램 활동을 실행합니다. 자원의 무리의 컬렉션의 구현은, 프로세스가 스레드 기반으로해야합니다.
이 과정은 적어도 하나 개의 스레드가 있어야합니다.
프로세스와 스레드의 차이점은 무엇입니까?
(1) 스레드가 메모리 공간을 공유 메모리 프로세스가 무관 한
동일한 프로세스, 두 프로세스가 중간 프록시를 통해 달성되어야 통신하려는 스레드 간 (2)의 직접 통신
(3) 새로운 쓰레드는 매우 간단 만들 새로운 프로세스를 생성하면 부모 프로세스의 복제 할 필요가
스레드가 동일한 프로세스에서 다른 스레드의 제어하고 작동 할 수 있습니다 (4)하지만, 프로세스는 자식 프로세스가 작동 할 수 있습니다
(5) 메인 스레드를 수정하는 다른 스레드의 작동에 영향을 미칠 수있는, 자식 프로세스의 부모에 대한 변경 사항은 영향을주지 않습니다
: 지식의 과정을
과정 (1)를 만들
단일 스레드 단순히 for 문을 멀티 스레드, 제거하려면 생성을
수입 멀티 스레딩, OS의
수입 시간이
데프 실행 (이름) :
time.sleep (2)
인쇄 ( "*************************** ************* ")
인쇄 ("모듈 이름 ", __ name__)
인쇄 ("부모 프로세스 ", os.getppid ())
인쇄 ("프로세스 ID : "os.getpid ())
인쇄 ( "프로세스 정보", multiprocessing.current_process ())
인쇄 ( "정보 스레딩", threading.current_thread을 ()) #进程里的主线程
인쇄 (% 이름 "[% (S)가] 과정") #进程里创建子线程
인쇄 ( "****************************************" )
t = threading.Thread (목표 = 핸들 인수 = (명))
t.start는 ()
: DEF (이름) 처리
( "[%의 (S)]가 스레드"인쇄% 이름)
인쇄 (threading.get_ident ())
만약 __name__ == '__ main__'
런 ( '주')
내지 I (10) :
p = multiprocessing.Process (목표 = 실행의 인수 = (I))
p.start ()
(2)와 프로세스 간 통신
A, 공정 대기열
그런 다음 아버지 자식 프로세스가 부모 프로세스의 복사본을 만들 때, 두 개의 프로세스 후 장소에서 질문의 순서에 피클을 기본 자식 프로세스가 충족 될 수 있기 때문에, 본질적으로 서로 다른 두 가지 목록이며, 대화 형 데이터를 가능하게 직렬화 복원 과정을 알아. 동일한 데이터를 수정하지, 단지 데이터 전송을 완료했다.
수입 멀티
데프 런 (Q) :
q.put ([42, 없음, '레오'])
인쇄 ( "자식 프로세스", 아이디 (Q))
의 경우 __name__ == "__ main__":
Q = multiprocessing.Queue ()
P = multiprocessing.Process (대상 = 실행, 인수 = (Q))
p.start ()
인쇄 (q.get ())
인쇄 ( "부모 프로세스", 아이디 (Q))
B 파이프 파이
import multiprocessing
def run(conn):
while True:
date = conn.recv()
print("sub process:%s\n"%date)
conn.send(date)
if __name__ =="__main__":
parent_conn,sub_conn = multiprocessing.Pipe()
p = multiprocessing.Process(target=run , args= (sub_conn,))
p.start()
while True:
com = input("from parent>>\n:")
parent_conn.send(com)
print("parent process :%s"%parent_conn.recv())
C、Manage
import multiprocessing,os
def run(i,d,l,lock):
lock.acquire() #锁
d[os.getpid()] = i
# l.append(os.getpid())
for a in range(1000):
l[0] +=1
print(l)
lock.release()
if __name__ =="__main__":
with multiprocessing.Manager() as manager:
# 相当于 manager=multiprocessing.Manager()
d = manager.dict()#生成一个字典,可在多个进程间共享和传递
l = manager.list(range(5))
p_list=[]
lock =multiprocessing.Lock()#进程锁,主要作用是输出屏幕的数据不乱
for i in range(10):
p = multiprocessing.Process(target=run , args=(i,d,l,lock,))
p_list.append(p)
p.start()
for i in p_list: #等待子进程执行完毕
i.join()
print(d)
print(l)
(3)进程池
进程池:进程太多,启动时开销太大,导致系统变慢。需要限制每次启动进程的个数。
必须先调用close()再调用join()
import multiprocessing,os,time
def run(i):
time.sleep(2)
print("[%s] is processing "%os.getpid())
return i+100,'xxxx'
def Bar(*args):#主进程调用回调
print('-->exec done:',args)
print('callback from :',multiprocessing.current_process())
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=5) #允许进程池里同时放入5个进程
for i in range(10):#启动了10个进程,同一时间只有5个进程运行
# pool.apply(func=run , args=(i,))#同步执行,串行
#pool.apply_async(func=run, args=(i,)) # 异步执行,并行
pool.apply_async(func=run, args=(i,),callback=Bar) # 异步执行,并行,callback回调
print('end')
pool.close()
pool.join()#进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。