企业官网建设流程全解析

一、进程概述, 1. 有关进程的具体介绍方面, 我们在编写程序的过程中, 要是想要去实现多任务的处理功能的话, 是可以使用进程这个东西来完成的, 因为进程本身就是实现多任务处理的一种非常重要的方式。

2. 关于进程的概念层面, 大家需要明确一点, 一个正在运行的程序也好, 或者是一个正在运行的软件也罢, 它都统统被称为是一个进程, 所以说呢, 进程它是操作系统进行管理的基础单元, 它是操作。

一、在进程概述的这一部分中, 我们首先需要对什么是进程给出一个详细的介绍。

在Python程序中，想要实现多任务可以使用进程来完成，进程是实现多任务的一种方式。

2. 进程的概念

一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位， 也就是说每启动一个进程，操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。

比如:现实生活中的公司可以理解成是一个进程，公司提供办公资源(电脑、办公桌椅等)，真正干活的是员工，员工可以理解成线程。

注意:
一个程序运行后至少有一个进程，一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程。

3. 进程的作用

单进程效果图:

这是那个多进程效果的图片。

说明: 多进程可以完成多任务，每个进程就好比一家独立的公司，每个公司都各自在运营，每个进程也各自在运行，执行各自的任务。

二、关于多进程的使用, 其第一步是导入进程包。

#导入进程包 import multiprocessing

2. 进程类的说明

()

所构建的实例对象, 其普遍采用的那一系列操作方法, 如下所示:

你所创建的那个实例对象, 它那些比较常用的一些属性, 也就是这些方面内容:

name是指当前进程的别名, 默认的值为负N, 这里的N是一个从1开始递增的整数。

3.这段代码使用了多进程技术, 以此来并行地完成多个相互独立的任务。

import multiprocessing import time# 跳舞任务def dance():foriinrange(5): print("跳舞中...") time.sleep(0.2)# 唱歌任务def sing():foriinrange(5): print("唱歌中...") time.sleep(0.2)if__name__=='__main__':# 创建跳舞的子进程# group: 表示进程组，目前只能使用None# target: 表示执行的目标任务名(函数名、方法名)# name: 进程名称, 默认是Process-1, .....dance_process=multiprocessing.Process(target=dance,name="myprocess1") sing_process=multiprocessing.Process(target=sing)# 启动子进程执行对应的任务dance_process.start() sing_process.start() 执行结果: 唱歌中... 跳舞中... 唱歌中... 跳舞中... 唱歌中... 跳舞中... 唱歌中... 跳舞中... 唱歌中... 跳舞中...

三、我们需要去获取那个进程编号, 这样做是为了搞明白为什么要拿到进程编号这件事。

获取进程编号这个目的, 其实是为了验证主进程和子进程关系, 这样就可以得知子进程, 是由那个主进程创建出来的。

这里提供了两种可以用来获取进程编号的操作方法。

2. 我们要去获取目前这个正在运行的进程所使用的编号。

通过调用 os.() 方法, 能够获取到正在运行的当前程序实例的编号。

示例代码: import multiprocessing import time import os# 跳舞任务def dance():# 获取当前进程的编号print("dance:", os.getpid())# 获取当前进程print("dance:", multiprocessing.current_process())foriinrange(5): print("跳舞中...") time.sleep(0.2)# 扩展:根据进程编号杀死指定进程os.kill(os.getpid(),9)# 唱歌任务def sing():# 获取当前进程的编号print("sing:", os.getpid())# 获取当前进程print("sing:", multiprocessing.current_process())foriinrange(5): print("唱歌中...") time.sleep(0.2)if__name__=='__main__':# 获取当前进程的编号print("main:", os.getpid())# 获取当前进程print("main:", multiprocessing.current_process())# 创建跳舞的子进程# group: 表示进程组，目前只能使用None# target: 表示执行的目标任务名(函数名、方法名)# name: 进程名称, 默认是Process-1, .....dance_process=multiprocessing.Process(target=dance,name="myprocess1") sing_process=multiprocessing.Process(target=sing)# 启动子进程执行对应的任务dance_process.start() sing_process.start() 执行结果: main:70763main: <_MainProcess(MainProcess, started)> dance:70768dance: 跳舞中... sing:70769sing: 唱歌中... 唱歌中... 唱歌中... 唱歌中... 唱歌中...

3. 我们要去获取一下那个当前正在执行的父进程具体的编号。

os.() 这个函数是用来获取当前的父进程编号的。

示例代码: import multiprocessing import time import os# 跳舞任务def dance():# 获取当前进程的编号print("dance:", os.getpid())# 获取当前进程print("dance:", multiprocessing.current_process())# 获取父进程的编号print("dance的父进程编号:", os.getppid())foriinrange(5): print("跳舞中...") time.sleep(0.2)# 扩展:根据进程编号杀死指定进程os.kill(os.getpid(),9)# 唱歌任务def sing():# 获取当前进程的编号print("sing:", os.getpid())# 获取当前进程print("sing:", multiprocessing.current_process())# 获取父进程的编号print("sing的父进程编号:", os.getppid())foriinrange(5): print("唱歌中...") time.sleep(0.2)if__name__=='__main__':# 获取当前进程的编号print("main:", os.getpid())# 获取当前进程print("main:", multiprocessing.current_process())# 创建跳舞的子进程# group: 表示进程组，目前只能使用None# target: 表示执行的目标任务名(函数名、方法名)# name: 进程名称, 默认是Process-1, .....dance_process=multiprocessing.Process(target=dance,name="myprocess1") sing_process=multiprocessing.Process(target=sing)# 启动子进程执行对应的任务dance_process.start() sing_process.start() 执行结果： main:70860main: <_MainProcess(MainProcess, started)> dance:70861dance: dance的父进程编号:70860跳舞中... sing:70862sing: sing的父进程编号:70860唱歌中... 唱歌中... 唱歌中... 唱歌中... 唱歌中...

四、关于进程的这样一个执行动作, 它是需要带着参数的, 这具体是指一个任务被执行的时候, 这个任务是要带有参数来执行的, 这里所介绍的是进程在执行为带有参数的任务时候的那些情况。

在前面的过程中, 咱们用进程去执行任务的时候, 那些任务是没有参数的, 要是现在我们要用进程执行的那些任务是带有参数的话, 那么究竟该怎么样给函数传递参数呢?

类别在执行具体任务并且需要把参数传递到这个任务里面的时候, 总共有两种不同的操作方式。

2. args参数的使用

示例代码: import multiprocessing import time# 带有参数的任务def task(count):foriinrange(count): print("任务执行中..") time.sleep(0.2)else: print("任务执行完成")if__name__=='__main__':# 创建子进程# args: 以元组的方式给任务传入参数sub_process=multiprocessing.Process(target=task,args=(5,)) sub_process.start() 执行结果: 任务执行中.. 任务执行中.. 任务执行中.. 任务执行中.. 任务执行中.. 任务执行完成

3. 参数的使用

示例代码: import multiprocessing import time# 带有参数的任务def task(count):foriinrange(count): print("任务执行中..") time.sleep(0.2)else: print("任务执行完成")if__name__=='__main__':# 创建子进程# kwargs: 表示以字典方式传入参数sub_process=multiprocessing.Process(target=task,kwargs={"count":3}) sub_process.start() 执行结果: 任务执行中.. 任务执行中.. 任务执行中.. 任务执行完成

五、关于进程的注意点, 首先得介绍这些注意点, 重点在于进程之间并不共享全局变量, 并且主进程会等待所有的子进程全部都执行结束了之后才结束, 具体来说就是进程之间不共享全局变量这一点。

import multiprocessing import time# 定义全局变量g_list=list()# 添加数据的任务def add_data():foriinrange(5): g_list.append(i) print("add:", i) time.sleep(0.2)# 代码执行到此，说明数据添加完成print("add_data:", g_list) def read_data(): print("read_data", g_list)if__name__=='__main__':# 创建添加数据的子进程add_data_process=multiprocessing.Process(target=add_data)# 创建读取数据的子进程read_data_process=multiprocessing.Process(target=read_data)# 启动子进程执行对应的任务add_data_process.start()# 主进程等待添加数据的子进程执行完成以后程序再继续往下执行，读取数据add_data_process.join() read_data_process.start() print("main:", g_list)# 总结: 多进程之间不共享全局变量执行结果: add:0add:1add:2add:3add:4add_data: [0,1,2,3,4] main: [] read_data []

关于进程它们彼此之间没有办法去共享全局变量这个东西, 它所呈现出来的那个解释效果的示意图,被表示如下。

3. 关于进程之间不共享全局变量这一情况, 在此做一个小结。通常情况下, 主进程会等待所有的子进程完全执行结束以后, 自身才会随之结束运行。

假如现在我们来创建一个子进程, 这个子进程大概需要耗费两秒钟的时间去执行完毕, 同时让主进程只执行零点五秒钟之后就退出当前的程序, 然后去查看具体的执行结果。

示例代码如下: import multiprocessing import time# 定义进程所需要执行的任务def task():foriinrange(10): print("任务执行中...") time.sleep(0.2)if__name__=='__main__':# 创建子进程sub_process=multiprocessing.Process(target=task) sub_process.start()# 主进程延时0.5秒钟time.sleep(0.5) print("over")exit()# 总结： 主进程会等待所有的子进程执行完成以后程序再退出执行结果: 任务执行中... 任务执行中... 任务执行中... over 任务执行中... 任务执行中... 任务执行中... 任务执行中... 任务执行中... 任务执行中... 任务执行中... 说明: 通过上面代码的执行结果，我们可以得知: 主进程会等待所有的子进程执行结束再结束 假如我们就让主进程执行0.5秒钟，子进程就销毁不再执行，那怎么办呢?

我们可以设置守护主进程 或者 在主进程退出之前 让子进程销毁
守护主进程:
守护主进程就是主进程退出子进程销毁不再执行
子进程销毁:
子进程执行结束

保证主进程正常退出的示例代码:
import multiprocessing
import time
# 定义进程所需要执行的任务
def task():
foriinrange(10):
print("任务执行中...")
time.sleep(0.2)
if__name__=='__main__':
# 创建子进程
sub_process=multiprocessing.Process(target=task)
#sub_process = multiprocessing.Process(target=task,daemon=True) #这样子也可以
# 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
# sub_process.daemon = True
sub_process.start()
time.sleep(0.5)
print("over")
# 让子进程销毁
sub_process.terminate()
exit()

# 总结： 主进程会等待所有的子进程执行完成以后程序再退出
# 如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

执行结果:
任务执行中...
任务执行中...
任务执行中...
over

5. 这是一个关于主进程会一直等待, 直到把所有的子进程都执行完毕了之后, 主自己才会结束的小结。