Python网络编程（进程池、进程间的通信）

import os 
from multiprocessing import Process 
from time import sleep

#获取文件的大小
size = os.path.getsize("./timg.jpeg")  # 获取文件的字节数
# f = open("timg.jpeg",'rb')
#复制前半部分
def copy1(img):
    f = open(img,'rb')  # 二进制读取要复制的文件
    n = size // 2
    fw = open('1.jpeg','wb')  # 二进制创建文件

    while True:
        if n < 1024:  # 判断文件大小是否大于1024字节 如果小于则直接读取写入
            data = f.read(n)
            fw.write(data)
            break
        data = f.read(1024)  # 否则每次循环读取1024字节并写入
        fw.write(data)
        n -= 1024
    f.close()
    fw.close()

#复制后半部分
def copy2(img):
    f = open(img,'rb')  # 读取文件必须要每次读取 如果在父进程中打开文件流对像 
                        # 子进程会通同时调用一个文件流对像 由于文件流对象特性会记录游标
                        # 如若先执行后半部复制这前半部会导致读取不到数据
    fw = open('2.jpeg','wb')
    f.seek(size // 2,0)
    while True:
        data = f.read(1024)
        if not data:
            break 
        fw.write(data)
    fw.close()
    f.close()

p1 = Process(target = copy1,args = ('timg.jpeg',))  # 创建子进程并让子进程分别同时复制
p2 = Process(target = copy2,args = ('timg.jpeg',))
p1.start()
p2.start()
p1.join()
p2.join()

from multiprocessing import Process 
import time 

class ClockProcess(Process):
    def __init__(self,value):
        #调用父类init
        super().__init__()
        self.value = value 
    #重写run方法
    def run(self):
        for i in range(5):
            time.sleep(self.value)
            print("The time is {}".format(time.ctime()))

p = ClockProcess(2)
#自动执行run
p.start()

p.join()

from multiprocessing import Pool 
from time import sleep,ctime 

def worker(msg):
    sleep(2)
    print(msg)
    return ctime()

#创建进程池对象
pool = Pool(processes = 4)

result = []
for i in range(10):
    msg = "hello %d"%i 
    #将事件放入进程池
    r = pool.apply_async(func = worker,args = (msg,))
    result.append(r)
    
    #同步执行
    # pool.apply(func = worker,args = (msg,))

#关闭进程池
pool.close()
#回收
pool.join()

#获取事件函数返回值
for i in result:
    print(i.get())

from multiprocessing import Pool
import time 

def fun(n):
    time.sleep(1)
    print("执行 pool map事件",n)
    return n ** 2 

pool = Pool(4)

#在进程池放入6个事件
r = pool.map(fun,range(6))  # map高阶函数 fun和iter执行6次
print("返回值列表:",r)

pool.close()
pool.join()

from  multiprocessing import Process,Value 
import time 
import random  

#创建共享内存
money = Value('i',6000)

#存钱
def deposite():
    for i in range(100):
        time.sleep(0.05)
        #对value的修改就是对共享内存的修改
        money.value += random.randint(1,200)
#花销
def withdraw():
    for i in range(100):
        time.sleep(0.04)
        #对value的修改就是对共享内存的修改
        money.value -= random.randint(1,200)

d = Process(target = deposite)
w = Process(target = withdraw)

d.start()
w.start()

d.join()
w.join()
print(money.value)

from multiprocessing import Process,Array
import time 

#创建共享内存
shm = Array('c',b"hello") #字符类型要求是bytes

#开辟5个整形单元的共享内存空间
# shm = Array('i',5)

def fun():
    for i in shm:
        print(i)
    shm[0] = b"H"

p = Process(target = fun)
p.start()
p.join()

print(shm.value) #从首地址打印字符串
# for i in shm:
#     print(i)