python进程开发

    程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。

   进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。

   进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。

  进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序 健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

例子：

#!/usr/local/python27/bin/python2.7

# coding=utf8

# noinspection PyUnresolvedReferences

from multiprocessing import Process

import time

def f(n):

time.sleep(1)

print n*n

for i in range(10):

p = Process(target=f,args=[i,])

p.start()

 在一般情况下多个进程的内存资源是相互独立的，而多线程可以共享同一个进程中的内存资源，示例代码：

#!/usr/local/python27/bin/python2.7

# coding=utf8

# noinspection PyUnresolvedReferences

# 通过多进程和多线程对比，进程间内存无法共享，线程间的内存共享

from multiprocessing import Process

import threading

import time

lock = threading.Lock()

def run(info_list,n):

    lock.acquire()

    info_list.append(n)

    lock.release()

    print('%s\n' % info_list)

info = []

for i in range(10):

'''target为子进程执行的函数，args为需要给函数传递的参数'''    

    p = Process(target=run,args=[info,i])

    p.start()

'''这里是为了输出整齐让主进程的执行等一下子进程'''    

time.sleep(1)    

print('------------threading--------------')

for i in range(10):

    p = threading.Thread(target=run,args=[info,i])

    p.start()

进程间通信：

#!/usr/local/python27/bin/python2.7

# coding=utf8

# noinspection PyUnresolvedReferences

# 通过multiprocessing.Queue实现进程间内存共享

from multiprocessing import Process,Queue

import time

def write(q):

    for i in ['A','B','C','D','E']:

        print('Put %s to queue' % i)

        q.put(i)

        time.sleep(0.5)

def read(q):

    while True:

        v = q.get(True)

        print('get %s from queue' %v)

if __name__ == '__main__':

    q = Queue()

    pw = Process(target=write,args=(q,))

    pr = Process(target=read,args=(q,))

    pw.start()

    pr.start()

    pr.join()

    pr.terminate()

进程池：

#!/usr/local/python27/bin/python2.7

# coding=utf8

# noinspection PyUnresolvedReferences

from multiprocessing import Pool

import time

def f(x):

    print x*x

    time.sleep(2)

    return x*x

'''定义启动的进程数量'''

pool = Pool(processes=5)

res_list = []

for i in range(10):

    '''以异步并行的方式启动进程，如果要同步等待的方式，可以在每次启动进程之后调用res.get()方法，也可以使用Pool.apply'''

    res = pool.apply_async(f,[i,])

    print('-------:',i)

    res_list.append(res)

pool.close()

pool.join()

for r in res_list:

    print(r.get(timeout=5))