使用python创建进程

from multiprocessing import Process		# 导入进程模块
import time

# 定义一个函数，测试创建进程使用
def task(name):
    print(name, '我是一个进程')
    time.sleep(3)
    print(name, '我现在运行完成啦')

# 执行进程，在windows中必须使用这种方法调用，否则会出现循环导入的情况，最终导致报错。
if __name__ == '__main__':
    process1 = Process(target=task, args=('子进程1号说>>>:',))   # 1
    process1.start()		 # 2
    print('我是主进程')		# 3


'''
返回结果：
    我是主进程
    子进程1号说>>>: 我是一个进程
    子进程1号说>>>: 我现在运行完成啦
整个main里面的执行过程说明：
1.创建一个进程对象
2.启动进程，告诉操作系统创建一个新的进程 并在该进程中执行task函数（异步）
3.打印“我是主进程”字符串（同步）
4.执行进程内部的函数体代码
'''

进程间的数据隔离

# 同一台计算机之间的多个进程数据是严格意义上的物理隔离的（在默认情况下）
# 测试代码如下：
from multiprocessing import Process
import time

money = 1000


def task():
    global money
    money = 666
    print('我是子进程task,我在查看变量money>>>:', money)


if __name__ == '__main__':
    print('函数执行前>>>:', money)
    task()
    print('函数执行后>>>:', money)
# 正常执行完以后，money变量被函数中的变量修改，最后变为666
'''
函数执行前>>>: 1000
我是子进程task,我在查看变量money>>>: 666
函数执行后>>>: 666
'''

# 如果我们把上面的执行过程换成进程执行：
if __name__ == '__main__':
    process1 = Process(target=task, )
    process1.start()
    time.sleep(3)
    print(money)   # 看输出结果可以看到，这里并未被函数中的变量修改
'''
此时的函数返回值：
    我是子进程task,我在查看变量money>>>: 666
    1000

这里就说明了什么是进程间的数据隔离
'''

进程join方法

from multiprocessing import Process
import time


def task(name, n=3):
    print('%s is running' % name)
    time.sleep(n)
    print('%s is over' % name)


if __name__ == '__main__':
    process1 = Process(target=task, args=('子进程1号>>>:', 1))
    process2 = Process(target=task, args=('子进程2号>>>:', 2))
    process3 = Process(target=task, args=('子进程3号>>>:', 3))
    start_time = time.time()
    process1.start()
    process2.start()
    process3.start()
    process1.join()
    process2.join()
    process3.join()
    print('我是主进程')
    print('我的执行时间>>>:', time.time() - start_time)
    '''
    返回值：
        子进程1号>>>: is running		# 进程1号占用时间1秒
        子进程2号>>>: is running		# 进程2号占用时间2秒
        子进程3号>>>: is running		# 进程3号占用时间3秒
        子进程1号>>>: is over
        子进程2号>>>: is over
        子进程3号>>>: is over
        我是主进程
        我的执行时间>>>: 3.185295581817627		# 三个进程执行时间为3秒出头
    
    结论：
    	1. 三个子进程执行完成以后，主进程才执行。
    	2. 三个进程并非是执行完一个再执行下一个，都是先创建好并执行函数体代码，但返回值的时候，是一个一个返回。
    '''

进程间通信的方法

'''
根据之前的实验得知，进程间严格意义上说是不能通信的（默认），但是也有方法可以通信（或者说传递数据），那就是使用消息队列，进程将产生的数据放到消息队列中，其他进程再去消息队列中取。
下面初步介绍一下Queue的简单用法：
'''

from multiprocessing import Queue
# 消息队列模块(复习：队列是先进先出，堆栈是先进后出)

# 1. 指定存放数据的个数
q = Queue(3)
# 2. 向消息队列中存放数据
q.put('我是第一个')
# 3. 可以判断队列是否已满
print(q.full())     # 返回False
# 4. 继续向队列中存放数据
q.put('我是第二个')
q.put('我是第三个')
print(q.full())     # 返回True
# 5. 因为在创建对象的时候指定的队列只能存放3个数据，所以再存放第四个的时候会出现等待现象。
# 6. 等待现象什么时候会结束？当有一个数据被取走的时候就对结束等待，将后面的数放入队列中。
# 7. 判断队列是否为空
print(q.empty())    # 返回False

查看进程的多种方法

from multiprocessing import Process, current_process
import os


def task():
    print(current_process())  # <Process name='Process-1' parent=39140 started> （可以看到它的父进程号是39140）
    print(current_process().pid)  # 34064   # 当前进程的进程号（这个是子进程）


# 1.查看进程
if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    print(current_process())  # <_MainProcess name='MainProcess' parent=None started> 
    print(current_process().pid)  # 39140  当前进程的进程号（这个是主进程）
    print(os.getpid())  # 39140    查看此进程的进程号
    print(os.getppid())  # 35544   查看父进程的进程号 (getppid 第一个p就是parent)

# # 2. 终止进程
#
# if __name__ == '__main__':
#     p1 = Process(target=task)
#     p1.start()
#     p1.terminate()  # 终止进程
#
# # 3. 判断进程是否存活
# if __name__ == '__main__':
#     p1 = Process(target=task)
#     p1.start()
#     p1.terminate()  # 终止进程
#     p1.is_alive()
#
# # 4. 创建守护进程
# if __name__ == '__main__':
#     p1 = Process(target=task)
#     p1.daemon = True  # 此时p1的父进程结束，p1不管是否运行完都会结束
#     p1.start()