python基础学习笔记之进程语法结构

# 进程：运行的程序至少会有一个进程，是操作系统进行资源分配的基本单位

#进程是资源分配的最小单位,他是操作系统进行资源分配和调度运行的基本单位,例如:正在运行的QQ 微信等都是进程

# 一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的

 

#进程语法结构

#multiprocessing模块就是跨平台版本的多进程模块,提供了一个Process类来代表一个进程对象,这个对象可以理解为一个独立的进程,可以执行另外的事情

from multiprocessing import Process  #导入多进程模块中的process类

 

#通过进程类创建进程对象

# Process类中参数:  #定义的进程对象=process(target=任务名)

# target():表示子进程要执行的任务

# args: 以元组的形式传值

# kwargs:以字典的形式传值

# name: 子进程名称，给进程设定一个名字，可以不设定

# 进程对象常用方法：    #定义的进程对象.start()启动进程

# start(): 开启子进程

# is_alive(): 判断子进程是否还活着，存活返回True

# join: 等待子进程终止

# 进程对象常用属性:    #print(定义的进程对象.name)查看进程名

# name: 当前进程的别名

# pid: 当前进程的pid(进程号)

# def a():

#     print(“第一个任务”)

#

# def b():

#     print(“第二个任务”)

#

# if __name__==”__main__”:

# #创建子进程(实例化对象)

#     p=Process(target=a)      #p=Process(target=a,name=”进程一”) 这样可以更改进程名,进程号不能修改

#     p1=Process(target=b)

# #开启子进程

#     p.start()

#     p1.start()

#     p.name=”进程一”  这是第二种更改进程名的方法

# #结果为:第二个任务

# #      第一个任务   和线程一样进程也是无序的

#

# #查看进程名,进程号

#     print(“p的进程名是:”,p.name)

#     print(“p的进程号是:”,p.pid)

#     print(“p1的进程名是:”,p1.name)

#     print(“p1的进程号是:”,p1.pid)

#结果为:p的进程名是: Process-1

#                 p的进程号是: 7528

#                 p1的进程名是: Process-2

#                 p1的进程号是: 9648  #这上面打印进程名,进程号属于主进程所以先执行

#                 第一个任务  #下面的是子进程

#                 第二个任务

 

import os  #通过os模块查看进程id

#os.getpid() 查看子进程id

#os.getppid() 父进程id

 

# def one():

#     print(f’one子进程id:{os.getpid()}, 父进程id:{os.getppid()}’)

#

# def two():

#     print(f’two子进程id:{os.getpid()}, 父进程id:{os.getppid()}’)

#

# if __name__ == ‘__main__’:

# #创建子进程对象, target只需要函数名

#     p1 = Process(target=one, name=’进程一’)

#     p2 = Process(target=two)

# #开启子进程

#     p1.start()

#     p2.start()

#     # 3.查看进程名， 进程号

#     # p2.name = ‘进程二’

#     # p1.pid = 123456   # AttributeError: can’t set attribute

#

#     # print(‘p1的进程名是：’, p1.name)

#     # print(‘p2的进程名是：’, p2.name)

#     # print(‘p1的进程号是：’, p1.pid)

#     # print(‘p2的进程号是：’, p2.pid)

#

#     # 4.is_alive(): 判断子进程是否还活着，存活返回True

#     # 5.join:等待子进程终止

#     # 主进程等待p1终止, 主进程处于等待的状态，子进程处于运行的状态

#     p1.join()

#     p2.join()  #阻塞过后子进程先执行

#

#     # print(‘p1的状态是：’, p1.is_alive())

#     # print(‘p2的状态是：’, p2.is_alive())

#

#     print(f’这是主进程, py文件进程号：{os.getpid()}, 父进程：{os.getppid()}’)

 

# win+r: 打开运行框 —- 输入cmd—进入命令提示符 # tasklist:查看系统的进程

# 步骤：打开命令提示符—输入tasklist, 回车 —  找到Pycharm64.exe— 查看对应的进程号

# Ctrl+F 查找

 

#进程资源不共享

import time

 

# li = []

# # 写数据

# def wdata():

#     for i in range(4):

#         li.append(i)

#         time.sleep(0.1)

#     print(‘写入的数据：’, li)

#

# # 读数据

# def rdata():

#     print(‘读取的数据：’, li)

#

#

# if __name__ == ‘__main__’:

#     w1 = Process(target=wdata)

#     r1 = Process(target=rdata)

#     w1.start()

#     w1.join()  # 等w1子进程执行完

#     r1.start()

#结果为:写入的数据：[0, 1, 2, 3]

#      读取的数据：[]

 

#实现进程资源共享

#队列–queue  先到先得

from queue import Queue

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

#q.put() 放入数据

# q.get()取出数据

# q.empty():如果队列为空，返回True

# q.qsize():队列包含的消息数量

# q.full():如果队列满了，返回True

 

# 初始化一个队列对象

# q = Queue(3)   # “3”表示最多可接收三条消息,为空表示有多少接收多少

# q.put(‘a’)     #放入数据

# q.put([1, 2, 3])

# q.put(‘c’)

#

# print(q.full())   #上面放入了三个数据所以这里为True

#

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

# print(q.get())

# print(q.get())

#

# print(q.empty())  #上面取出了三个数据队列为空,所以结果为:True

# print(‘现在的消息数量：’, q.qsize())   #结果为:0  数据都已经取出

 

# 进程操作队列

from multiprocessing import Process, Queue

import time

 

# li = []

# # 写数据

# def wdata(q1):

#     for i in range(1,5):

#         li.append(i)

#     for t in li:

#         print(f’需要放入的是:{t}’)

#         # 2.放入数据

#         q1.put(t)

#         #time.sleep(0.2)

#

#

# # 读数据

# def rdata(q2):

#     # 3.取出数据

#     while True:

#         # 判断队列是否为空，为空就跳出循环

#         if q2.empty():

#             break

#         else:

#             print(‘取出的是:’, q2.get())

#

# if __name__ == ‘__main__’:

#     # 1.创建队列对象

#     q = Queue()  # 省略此参数，无大小限制

#     # 创建子进程对象

#     w1 = Process(target=wdata, args=(q, ))

#     r1 = Process(target=rdata, args=(q, ))

#     # 开启子进程

#     w1.start()

#     # 等待w1结束, 等放完数据

#     w1.join()

#     # 再去取出数据

#     r1.start()

#结果为:需要放入的是:1

#      需要放入的是:2

#      需要放入的是:3

#      需要放入的是:4

#      取出的是: 1

#      取出的是: 2

#      取出的是: 3

#      取出的是: 4

 

# 进程池

# 概念：定义一个池子，在里面放上固定数量的进程，有需求，就拿池子中的进程来处理任务。

# 处理完毕，进程并不关闭，而是将进程放回到进程池中继续等待任务。

 

# 2.主要方法

# p.apply_async(func, args):异步非阻塞

# p.close():关闭进程池，防止进一步操作

# p.join(): 主进程阻塞，等待所有工作进程退出。(必须在close()之后调用)

 

# 阻塞与非阻塞指的是程序的两种运行状态

# 阻塞：遇到I/O就发生阻塞，程序一旦遇到阻塞操作就会停在原地，并且立刻释放CPU资源

# 非阻塞：没有遇到I/O操作

 

# 同步与异步指的是提交任务的两种方式

# 同步：提交完任务后，在原地等待，直到任务执行完毕后，拿到任务的返回值，才继续执行下一行代码

# 异步：提交完任务后，不在原地等待，直接执行下一行代码

 

# 打电话：同步通信

# 发短信：异步通信

 

 

# 举例

 

from multiprocessing import Pool

import time

 

# def work(a):

#     print(‘第一个work’)

#     time.sleep(2)

#     return a*2

#

# if __name__ == ‘__main__’:

#     # 定义一个进程池,最大进程数3

#     p = Pool(3)

#     li = []  # 定义空列表，接收返回值

#     for i in range(6):   #六个任务进程数是三,就一次执行三个任务

#         # apply_async(目标函数名, 要传递的参数)

#         # 根据进程池中有的进程数，每次最多3个子进程在异步执行

#         res = p.apply_async(work, args=(i, ))

#         li.append(res)

#

#     # 关闭进程池

#     p.close()

#     # 等待进程池中所有子进程执行完成

#     p.join()

#

#     # 使用get方法来获取apply_async()的结果

#     for i in li:

#         # print(i)

#         print(i.get())