python在windows和linux环境的进程对比及进程和进程之间的通信

1.fork进程：
（1）在windows系统中不可以用fork来创建进程，linux可以，但是创建大量进程使用很不方便。

2.Process进程：

#多任务，进程
from multiprocessing import Process
import time
def test():
    while True:
        print("-------test------")
        time.sleep(1)
def test1():
    while True:
        print('------test2')
        time.sleep(2)

def main():
    p1= Process(target=test) #开启一个进程
    p1.start()#让这个进程开始执行test函数里面的代码
    p2=Process(target=test1)
    p2.start()
    p1.join() #等待 就是join会让子进程进行完（完成），才会执行主进程（join还可以带参数 等待多长时间）
    print('---主进程----')
if __name__ == '__main__':
    main()

windows下运行结果：

-------test------
------test2
-------test------
-------test------
------test2
-------test------
-------test------
------test2
-------test------
-------test------
------test2
-------test------

说明：

（1）if __name__ == '__main__':
在windows环境下创建进程及相关的可执行代码必须放在if __name__ == '__main__'：下，否则会报错；但是linux系统没有这个问题。

 三：进程池Pool

     当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态生成多个进程，但如果是成百上千个目标时，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块中提供的Pool .

     初始化Pool时，可以指定一个最大的进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行。 1 from multiprocessing import Pool

def worker():
    print('-----这里是要执行的任务')
def test():
    po = Pool(3)  # 在这里创建线程池，3 是代表这个线程池中线程最大数量是3
    po.apply_async(worker())  # 向线程中添加任务，（就是开辟线程）(apply_async()是非堵塞的方式){po.apply(worker)这个是堵塞的方式}

    po.close() #关闭线程池，相当于不在添加新任务了
    po.join() #等待所有的子进程执行完成，必须放在close之后（主进程创建/添加任务后，主进程 默认不会等待进程池中的任务完成后才结束，而是 当主进程做完任务后 立刻结束，，，如果这个地方没有join，会导致进程池中的任务不会执行）

if __name__ =='__main__':
    test()

运行结果：

-----这里是要执行的任务

（1）Pool进程也一样，在windows环境下相关的可执行代码必须放置在if __name__ == '__main__'下。

 四：进程间通信：Queue

        proccess之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。

可以使用multiprocessing模块中的Queue实现多进程之间的数据传递，Queue本身就是一个消息列队程序

>>> q = Queue(3)# 初始化一个Queue对象，最大可接收三条put消息
>>> q.qsize() #返回当前队列包含的消息数量
0
>>> q.put('第一条消息')#向当前队列添加数据
>>> q.qsize()
1
>>> q.put('第二条消息')
>>> q.put('第三条消息')
>>> q.qsize()
3
>>> q.get()# 从队列里取出数据，（先进先出）
'第一条消息'
>>> q.qsize()
2
>>> q.get()
'第二条消息'
>>> q.qsize()
1
>>> q.get()
'第三条消息'
>>> q.qsize()
0
>>> q.empty()#判断当前队列是否为空，为空则返回True,否则返回False
True
>>> q.full()#判断当前队列是否是满的，满的则返回True,否则返回False
False
>>> q.put('再添加一条消息')
>>> q.get() #get()从队列里取数据如果有数据就会直接取出来，否则会一直等待
'再添加一条消息'
>>> q.get_nowait()#从队列里取数据如果没有数据则不以等待，直接会以异常提示
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    q.get_nowait()#从队列里取数据如果没有数据则不以等待，直接会以异常提示
  File "E:pythonlibmultiprocessingqueues.py", line 126, in get_nowait
    return self.get(False)
  File "E:pythonlibmultiprocessingqueues.py", line 107, in get
    raise Empty
queue.Empty
>>>  

Process创建进程之间的通信

 示例代码：

#进程间的通信，Process版的
from multiprocessing import Queue
from multiprocessing import Process
def writer(a):
        print('向队列中添加数据')
        x = a.put('写入的数据')
def read(b):
    print('读取队列中的数据')
    if b.empty()== False:
        y =b.get()
        print(y)
    else:
        print('没有数据')
if __name__ == '__main__':
    q = Queue()  # 使用Queue()来初始化
    p1= Process(target=writer,args=(q,))
    p2=Process(target=read,args=(q,))
    p1.start()
    p2.start()

运行结果:

向队列中添加数据
读取队列中的数据
写入的数据

Pool进程池创建进程之间的通信

注意：Pool进程池创建的进程之间通信，需要导入Manager

示例代码：

#进程间的通信 Pool
from multiprocessing import Manager
from multiprocessing import Pool
def writer(a):
        print('向队列中添加数据')
        a.put('写入的数据')
def read(b):
    print('读取队列中的数据')
    if b.empty()== False:
        y =b.get()
        print(y)
    else:
        print('没有数据')
def test():
    q =Manager().Queue()  # 使用Manager中的Queue()来初始化
    p=Pool(3)
    p.apply_async(writer,(q,))
    p.apply_async(read,(q,))
    p.close()
    p.join()
if __name__ =='__main__':
    test()

运行结果：

向队列中添加数据
读取队列中的数据
写入的数据

一个多进程和进程通信的实例代码：

 实现多进程拷贝文件夹

import os
from multiprocessing import Manager,Pool
import time

def copyFileTask(name,oldFolderName,newFolderName,qu):
    '拷贝文件操作'
    fr = open(oldFolderName+'/'+name,'r',encoding='utf-8')
    content = fr.read(1024)
    fw = open(newFolderName+'/'+name,'w',encoding='utf-8')
    fw.write(content)
    fr.close()
    fw.close()
    qu.put(name)

def main():
    startTime=time.time()
    oldFolderName = input("请输入你要拷贝的文件夹名称：") #获取要拷贝的文件夹名称
    #读取文件夹中所有的文件名
    listNames =  os.listdir(oldFolderName)
    #创建一个新的文件夹
    newFolderName = oldFolderName+'复件'
    os.mkdir(newFolderName)
    #创建进程池，实现多任务
    po = Pool(5)
    qu=Manager().Queue()
    #遍历listNames，获取每一个文件的名称
    for name in listNames:
        po.apply_async(copyFileTask,args=(name,oldFolderName,newFolderName,qu))

    num = 0
    allNum= len(listNames)
    while num < allNum:
        qu.get()
        print()
        num += 1
        copyRote= num/allNum # 求出拷贝的进度条
        print('copy的进度是：%.2f%%'%(copyRote*100),end='')
        print('')
        overTime=time.time()
        allTime=overTime - startTime
        print(allTime)
if __name__ == '__main__':
    main()

运行结果：

请输入你要拷贝的文件夹名称：aaaa

copy的进度是：4.35%
3.575204372406006

copy的进度是：8.70%
3.575204372406006

copy的进度是：13.04%
3.579204559326172

copy的进度是：17.39%
3.580204725265503

copy的进度是：21.74%
3.581204652786255

copy的进度是：26.09%
3.585205078125

copy的进度是：30.43%
3.585205078125

copy的进度是：34.78%
3.588205099105835

copy的进度是：39.13%
3.588205099105835

copy的进度是：43.48%
3.589205265045166

copy的进度是：47.83%
3.593205451965332

copy的进度是：52.17%
3.595205307006836

copy的进度是：56.52%
3.595205307006836

copy的进度是：60.87%
3.596205472946167

copy的进度是：65.22%
3.600205898284912

copy的进度是：69.57%
3.601206064224243

copy的进度是：73.91%
3.602205991744995

copy的进度是：78.26%
3.603205919265747

copy的进度是：82.61%
3.60520601272583

copy的进度是：86.96%
3.609206199645996

copy的进度是：91.30%
3.610206365585327

copy的进度是：95.65%
3.6122066974639893

copy的进度是：100.00%
3.613206624984741