파이썬 과정 작은 노트 (1)

프로세스 : 데이터 세트의 개별 기능을 갖는 프로그램 활동을 실행합니다. 자원의 무리의 컬렉션의 구현은, 프로세스가 스레드 기반으로해야합니다.

　　이 과정은 적어도 하나 개의 스레드가 있어야합니다.

프로세스와 스레드의 차이점은 무엇입니까?

(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()#进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。

파이썬 과정 작은 노트 (1)

추천