Python 进程和线程

对于OS来说，一个任务(如打开word)就是一个进程

有些进程不止同时干一件事，如word可以同时进行打字、拼写检查、打印等事情，进程内的子任务称为线程

 

多进程

multiprocessing模块  跨平台版本的多进程模块

启动一个子进程并等待其结束

#!/usr/bin/python3

from multiprocessing import Process
import os

#子进程要执行的代码
def run_proc(name):
    print('运行的子进程 %s(%s)' % (name, os.getpid()))
    
if __name__ == '__main__':
    print('父进程 %s' % os.getpid())
    p = Process(target = run_proc, args = ('qwer',))  #创建子进程对象
    print('子进程将要开始运行--------')
    p.start()
    p.join()  #等待子进程结束后再继续往下运行，通常用于进程间的同步
    print('子进程结束---------')

子进程只需要调用getpid()就可拿到父进程ID

 

Pool    启动大量的子进程  用进程池的方式

#!/usr/bin/python3

from multiprocessing import Pool
import os,time,random

def long_time_task(name):
    print('Run task %s (%s)-----' % (name, os.getpid()))
    start = time.time() #放回当前时间戳
    time.sleep(random.random()*3)
    end = time.time()
    print('Task %s runs %0.2fs' % (name, (end-start)))

if __name__ == '__main__':
    print('父进程 %s' % os.getpid())
    p = Pool(4)  #设置同时跑四个进程
    for i in range(5):
        p.apply_async(long_time_task, args = (i,))  #apply应用程序  asvnc异步化
    print('等待所有子程序完成------')
    p.close()
    p.join()  
    print('所有子程序完成')

调用join()之前必须先调用close()

 

进程间通信

Process之间肯定是需要通信的，Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

#!/usr/bin/python3

from multiprocessing import Process,Queue
import os,time,random

#写数据
def write(q):
    print('写进程: %s' % os.getpid())
    for value in ['A', 'B', 'C']:    
        print('Put %s to queue------' % value)
        q.put(value)
        time.sleep(random.random())
        
#读数据
def read(q):
    print('读进程: %s' % os.getpid())
    while True:
        value = q.get(True)
        print('Get %s from queue------' % value)
        
if __name__ == '__main__':
    #父进程创建Queue,并传给各个子进程
    q = Queue()
    pw = Process(target = write, args = (q,))
    pr = Process(target = read, args = (q,))
    #启动子进程pw,写入
    pw.start()
    #启动子进程pr,读取
    pr.start()
    #等待pw结束
    pw.join()
    #pr进程死循环，无法等待其结束，强行终止
    pr.terminate()

 

 

多线程

启动一个线程就是把一个函数传入并创建Thread(实例)，然后start()执行

#!/usr/bin/python3

import time,threading

#线程要执行的代码
def loop():
    print('Thread %s is runing----' % threading.current_thread().name)
    n = 0
    while n<5:
        n = n+1
        print('thread %s>>>%s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s end' % threading.current_thread().name)
    
print('thread %s is runing----' % threading.current_thread().name)
t = threading.Thread(target = loop, name = 'LoopThread')
t.start()
t.join()
print('thread %s end' % threading.current_thread().name)

任何进程默认会启动一个线程（主线程），主线程又可以启动新的线程，current_thread()函数返回当前线程的实例，如果不给子线程指定名字，默认Thread-1,Thread-2........

 

Lock

多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响

多线程中，所有变量都由所有线程共享，为防止修改冲突，需给线程上锁，锁只有一个，同一个时刻最多只有一个线程持有该锁

#!/usr/bin/python3

import time,threading

balance = 0  #假定这是银行存款

def change_it(n):  #先存后取，结果应该为0
    global balance
    balance = balance + n
    balance = balance - n

lock = threading.Lock()  #创建锁对象

def run_thread(n):
    for i in range(100000):
        lock.acquire()   #上锁
        try:
            change_it(n)
        finally:  #改完一定要释放锁
            lock.release()
        
t1 = threading.Thread(target = run_thread, args = (5,))
t2 = threading.Thread(target = run_thread, args = (10,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

没上锁时，数据冲突

上锁后