17 进程

1.进程介绍

2.进程创建

3.进程间的通信

4.进程池

# 进程介绍：一个程序运行起来后，代码+用到的资源称之为进程

# 1.进程状态：
# 就绪态：正在等CPU执行
# 执行态：CPU正在执行其功能
# 等待态：等待某些条件满足

# import time
# print('程序开始')  #  运行状态
# name = input('请输入你的名字：')  # 用户输入，进入阻塞
# print(name)       # 运行状态
# time.sleep(1)         # 睡眠， 阻塞状态
# print('程序结束')      # 运行状态

# 2.进程语法结构
# multiprocessing 模块       Process类

# Process()参数：
# target：表示调用对象，子进程要执行的任务
# args: 传递参数，以元组的形式传递
# kwargs: 以字典的形式传递参数
# name: 子进程名称

# Process()常用方法：
# start():启动子进程
# is_alive():判断子进程是否还活着，存活返回True, 否则False
# join(): 主进程等待子进程终止

# Process()常用属性：
# name：当前进程的别名
# pid: 当前进程的进程号

# 3.属性举例
# from multiprocessing import Process
# import os
# os.getpid() : 获取当前进程的进程号
# os.getppid(): 获取父进程的进程号

# def one():
#     print('one子进程id:%s, 父进程id:%s' % (os.getpid(), os.getppid()))
#
# def two():
#     print('two子进程id:%s, 父进程id:%s' % (os.getpid(), os.getppid()))
#
# if __name__ == '__main__':
    # 创建子进程
    # p1 = Process(target=one)
    # p2 = Process(target=two)

    # 开启子进程
    # p1.start()
    # p2.start()
    # print('one中的pid:', p1.pid)

    # p1.name = '九歌'
    # print('p1的进程名是：', p1.name)
    # print('主进程：%s, 父进程：%s' % (os.getpid(), os.getppid()))


# 4.# is_alive():判断子进程是否还活着，存活返回True, 否则False
# # join(): 主进程等待子进程终止
# from multiprocessing import Process
#
# # def one():
# #     print(123)
# #
# # def two():
# #     print(456)
# #
# # if __name__ == '__main__':
# #     # 创建子进程
# #     p1 = Process(target=one)
# #     p2 = Process(target=two)
# #     # 开启子进程
# #     p1.start()
# #     p2.start()
# #     p1.join()  # 主线程等待p1终止, 主进程处于等待的状态，p1处于运行的状态
# #     p2.join()
#
#
#     # print('这是主进程')
#     # print('p1的状态是:', p1.is_alive())
#     # print('p2的状态是:', p2.is_alive())



# # 5. 进程不会共享全局变量
# import time
#
# li = []
# # 写入：
# def funa():
#     for i in range(3):
#         li.append(i)
#         # time.sleep(1)
#         print('这是funa中的：', li)
#
# # 读取：
# def funb():
#     print('这是funb中的：', li)
#
#
# if __name__ == '__main__':
#     p1 = Process(target=funa)
#     p2 = Process(target=funb)
#     p1.start()
#     p1.join()  # 阻塞主进程
#     p2.start()
#

# 1. Queue  队列   先进先出
# 入队：将一个数据放到队列尾部      q.put()  放入数据
# 出队：从队列的头部取出一个元素    q.get() 取出数据


# from queue import Queue
# q = Queue()  # 初始化一个Queue对象
# q.put(123)   # 放入数据
# q.put('b')
# q.put([1, 2, 3])
# q.put('a')

# Queue.full()   如果队列满了，返回为True, 否则为False
# print(q.full())

# print(q.get())  # 取出数据
# print(q.get())
# print(q.get())

# Queue.empty()  如果队列为空，返回为True, 否认为False

# print(q.empty())
# print('现在的消息数量：', q.qsize())

# 2. 进程操作队列
#
# from multiprocessing import Process, Queue
# import time
# import random
#
# li = ['a', 'b', 'c', 'd']
#
#
# # 写数据
# def write(w1):  # 放入数据,  w1实际就是q,也就是初始化的Queue对象
#     for i in li:
#         print('将%s放进队列中' % i)
#         w1.put(i)
#         time.sleep(random.random())
#
#
# # 读数据
# def read(r1):    # 取出数据
#     while True:
#         if not r1.empty():
#             val = r1.get()
#             print('从队列中获取：', val)
#             time.sleep(random.random())
#         else:
#             break
#
#
# if __name__ == '__main__':
#     # 初始化一个Queue对象
#     q = Queue()  # 忽略此参数，没有大小限制
#     p1 = Process(target=write, args=(q, ))
#     p2 = Process(target=read, args=(q, ))
#     # 启动子进程p1, 先放入数据
#     p1.start()
#     # 等待p1放完
#     p1.join()
#     # 启动子进程p2，取出数据
#     p2.start()
#     # print('p2的is_alive', p2.is_alive())

from multiprocessing import Process, Queue
import time
import random


li = ['a', 'b', 'c', 'd']


def write(w):
    for i in li:
        print('将%s放入队列中' % i)
        w.put(i)
        time.sleep(random.random())


def read(r):
    while True:
        if not r.empty():
            print('从队列读到的数据为：', r.get())
            time.sleep(random.random())
        else:
            break


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=write, args=(q, ))
    p2 = Process(target=read, args=(q, ))
    p1.start()
    p1.join()
    p2.start()
    print(p1.is_alive())
    print(p2.is_alive())

# # 1.进程池：定义一个池子，里面放上固定数量的进程。


# # 主要方法：
# # apply_async: 非阻塞
# # apply：阻塞
# # close():关闭进程池
# # join(): 主进程阻塞（只能在close之后调用）
#
#
# from multiprocessing import Pool
# import time
#
# def work(n):
#     print('我们在上课')
#     time.sleep(0.5)
#     return n ** 2
#
# # 2.异步
# # apply_async：异步非阻塞， 不用等待当前进程执行完毕，
#				随时根据系统调度来进行进程切换
# # apply_async(任务名, 参数)
#
#
# # if __name__ == '__main__':
# #     # 创建进程池
# #     p = Pool(3)
# #     li = []
# #     for i in range(6):   # i的值：0-5
# #         res = p.apply_async(work, args=(i, )) # 根据进程池中有的进程数，每次最多有3个子进程在异步运行
# #         li.append(res)
# #
# #
# #     p.close()  # 关闭进程池
# #     p.join()   # 等待所有子进程执行完
# #
# #     # 使用get方法来获取apply_async的结果
# #     for j in li:
# #         print(j.get())
#
# # 3.同步
# # apply：同步阻塞，等待当前子进程执行完，再执行下一个进程
# # if __name__ == '__main__':
# #     # 创建进程池
# #     p = Pool(3)
# #     li = []
# #     for i in range(6):
# #         res = p.apply(work, (i, ))
# #         li.append(res)
# #
# #     print(li)
#
# # 4.进程池通信
# from multiprocessing import Pool, Manager
# import os
#
# # 写数据
# def write(q1):
#     print('write的进程号：%s, 父进程：%s' % (os.getpid(), os.getppid()))
#     for i in 'six':
#         print('write中的：', i)
#         q1.put(i)  # 放入数据
#
# # 读数据
# def read(q2):
#     print('read的进程号：%s, 父进程：%s' % (os.getpid(), os.getppid()))
#     for i in range(q2.qsize()):  # q.qsize() 返回队列中数据的数量
#         print('取出数据：', q2.get())
#
#
# if __name__ == '__main__':
# # print('开始的：', os.getpid())
# # 实例化一个队列对象
#
#     q = Manager().Queue()
#     p = Pool()  # 创建进程池
#     p.apply_async(write, (q, ))
#     p.apply_async(read, (q, ))
#
#     p.close()
#     p.join()
#

from multiprocessing import Pool, Manager
import os


def write(q1):
    print('write of id: %s, father id: %s' % (os.getpid(), os.getppid()))
    for i in 'six':
        print('write: ', i)
        q1.put(i)


def read(q2):
    print('read id: %s, father id: %s' % (os.getpid(), os.getppid()))
    for i in range(q2.qsize()):
        print('read data:', q2.get())


if __name__ == '__main__':      # 加主程序入口后，若此文件被其他文件导入，这下面的代码不会被执行
    print('process id: ', os.getpid())
    q = Manager().Queue()
    p = Pool()
    p.apply(write, (q,))
    p.apply(read, (q, ))

    p.close()
    p.join()