03网络编程多任务/多进程

o1什么是进程.py

import multiprocessing
import threading
"""
复习
1,线程轻量级,解决单任务的问题,可以同时执行多个函数,线程执行顺序不一定,子线程执行完毕后才会结束主线程
2,线程之间全局变量共享,同时读写容易出错,可以使用Lock类创建进行加锁,或者超时控制,注意防止死锁
"""
"""
进程,进程是程序运行后的一种形态,可以调用各种系统资源,实现多任务的另外一种方式
但是进程完成多任务占用资源相当大,进程创建后,主进程所有东西都会被子进程复制一份    
进程的模块multiprocessing 

进程的状态   运行--就绪--等待--死亡
进程的创建   multiprocessing.Porcess类创建对象,调用对象start方法与线程非常相似

进程是资源分配的单位,线程是在进程中运行,

先多线程,多线程无法满足在执行多进程

"""
# 现有进程-再有线程,多线程的意思是在一个进程中实现多个线程
    # 而多进程是开启多个进程,多个进程中每个进程可以包含多个线程
"""

def test1():
    for i in range(1000):
        print('test1')
def test2():
    for i in range(1000):
        print('test2')

def  main():
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)
    t1.start()
    t2.start()

if __name__ == '__main__':
    main()
"""

def test1():
    while True:
        print('test1')
def test2():
    while True:
        print('test2')

def  main():
    #  创建进程
    p1 = threading.Thread(target=test1)
    p2 = threading.Thread(target=test2)
    p1.start()
    p2.start()

if __name__ == '__main__':
    main()

o2_进程之间的通信.py

import multiprocessing
#  Learner BM
""
"""
1,进程之间的通信方式,1,使用套接字网络通信.2,使用硬盘文件进行读写通信,但效率太低.3,使用内存之间进行通信,队列

队列

Queue,系统中的一部分内存空间multiprocessing模块
q= QUeue(3)   创建一个队列,存储3个消息 ,先进先出,后进后出
q.full()        查看队列是否满了  bollean类型返回值
q.enpty()       查看队列是否清空  bollean类型返回值
q.put()        存放数据,类型任意
q.get()        取出数据
"""
"""
通信步骤
1,创建队列
2,创建进程
3,将队列当做参数,传递到进程当中
4,调用进程
"""
def down(q1):
    #  举例,下载的列表
    down_data = [11,22,33]
    #  遍历列表
    for i in down_data:
        # 放入数据
        q1.put(i)
    # 打印
    print('下载完毕,交给analyze处理')
def analyze(q1):
    # 定义列表,用于存储get到的数据
    list1 = list()
    while True:       # 循环取出数据
        # get数据存入data
        data = q1.get()
        # data存入list中
        list1.append(data)
        #  如果对列为空,结束循环
        if q1.empty():
            break
    print('analyze完毕,结果是%s' % list1)
    #q1.get()
    print(q1.get())
def main():
    #  定义队列
    q1= multiprocessing.Queue()
    #  定义进程,target目标,与args多值参数与线程 threading 一致
    p1 = multiprocessing.Process(target=down,args=(q1,))
    p2 = multiprocessing.Process(target=analyze,args=(q1,))
    #  启动进程
    p1.start()
    p2.start()
if __name__ == '__main__':
    main()

o3_进程池.py

import multiprocessing
import os
import time
import random
#  Learner BM
""
"""
多进程实现多任务,但是并不是进程越多越好,当任务数量不固定的时候,因此可以通过创建进程池,实现进程之间的调配
进程池,通过创建进程池,存储创建的进程,通过合理调配,实现以少量的进程完成不同的任务
注意,进程池与进程不同
    进程,等待子进程执行完毕在执行后续代码
    进程池,不会等待子进程完毕,所以需要人为控制,使用join()方法,等待子进程执行完毕

# 创建进程池 ,注意windows下进程池的创建调用必须在main()函数下,否则会报错

def main():
    创建进程池,包含3个进程
    po = multiprocessing.Pool(3)
    
    配合for 循环,设置def需要执行的次数
    for i in range(0, 10):
        po.apply_async(demo, (i,))

    po.close()
    po.join()


"""
def demo(msg):
    for i in  range(random.randint(1,10000)):
        print('这是第%s进程执行任务%s任务' % (msg,i))
    # t_start = time.time()
    # print('%s开始执行,进程号为%d' % (msg,os.getegid()))
    # time.sleep(random.random()*2)
    # t_stop = time.time()
    # print(msg,'执行完毕,耗时%0.2f' % (t_stop-t_start))
"""
注意,win下
"""
def main():

    po = multiprocessing.Pool(3)

    for i in range(0, 10):
        po.apply_async(demo,(i,))


    po.close()
    po.join()

if __name__ == '__main__':
    main()

o4_多进程文件复制.py

import os
import multiprocessing
""""""
"""
1,进程池的创建必须配合close方法和join方法使用
2,进程池任务的添加,一般配合for循环,循环遍历
3,进程池内部调用的函数出错,不会输出任何信息


"""

#
def copy(file_name,old_floder,new_floder):
    #  组合文件名及路径,
    old_path_name = str(old_floder +'/'+ file_name)
    # 打开文件,参数为文件名及路径,
    f_old = open(old_path_name,'r',encoding='utf-8')
    text=f_old.read()

    # #读取文件
    new_path_name = str(new_floder +'/'+ file_name)
    f_new = open(new_path_name,'w',encoding='utf-8')
    f_new.write(text)
    f_new.close()
    f_old.close()

def main():

    # 获取用户需要拷贝文件夹的名字
    old_floder=input('请输入需要拷贝的目录文件名')
    # 创建新的文件夹

    new_floder = old_floder+'[附件]'
    os.mkdir(new_floder)
    print(new_floder)


    # 获取文原件夹内部文件的名字  os.listdir
    file_names = os.listdir(old_floder)

    # 多任务创建进程池,必须配合close和join方法,否则无法显示进程执行步骤
    po = multiprocessing.Pool(3)

    for filename in file_names:
                            #参数 文件名,源文件夹,目标文件夹
        po.apply_async(copy,args=(filename,old_floder,new_floder))

        # 复制原文件夹中文件到新文件夹中去copy函数执行
    # 必须配合close和join
    po.close()
    po.join()

if __name__ == '__main__':
    main()