python知识点相关笔记

进程
概念
一个服务上运行着多个任务
在电脑的运行中
同一时间可以运行很多程序
每一个程序都会占用一定的CPU
只有程序在服务上运行起来，才算是进程
简单来说，进程就是程序的一次运行
时间片轮转
单核cpu不是同时运行很多个进程
只是切换时间够快
并发
进程数大于CPU核数
并行
进程数小于CPU的核数
一般情况都是并发
定义
程序：是一个指令的集合
进程：是一个正在执行的程序（静态的概念）
进程是程序的一次静态执行过程，占用特定的地址空间
每个进程都是独立的，分为三部分 cpu、data、code
缺点：内存的浪费，CPU的负担
分时处理
CPU在执行多进程的时候采用的是分时处理机制
分时处理机制就是把时间分成极小的单位
比如说是个任务，每个任务做1毫秒
我们根本看不出来多进程的运行方式
由于CPU的速度太快和分时处理，所以我们看到的程序就像是同时执行一样
主要设计模块
import os ：进程的数据
from multiprocessing improt Process ：创建进程
time ：时间模块
from multiprocessing improt Pool ：进程池
创建进程
引入包
再引入os包
或者直接将multiprocessing全部都引入进来
引入 multiprocessing包中的Process类
创建出子进程要执行的代码
创建一个函数
函数中执行检测创建子进程的代码
判断测试代码
输出父进程的ID
实例化类，创建一个子进程
启动进程
实现进程的同步
检测进程同步的输出
实例
from multiprocessing import Process
import os
#将要执行的代码，用来输出创建的额子进程
def zjc(name):
#输出子进程的ID
print(‘这是紫禁城的代码，他的参数是%s，子进程的ID是%d’%(name,os.getpid()))
#创建一个函数，进行创建一个子进程
if name == ‘main’:
#输出父进程的ID
print(‘这是父进程的代码，他的ID为%d’%(os.getpid()))
#实例化引入的包，创建子进程
#第一个参数传入函数的名字，需要调用的函数，也就是创建子进程的同时检测子进程的代码
#第二个参数传入的是一个元组元组中的元素就是调用函数中的参数
p = Process(target=zjc,args=(‘grandmather’,))
#启动进程
p.start()
#实现进程的同步，等待所有的进程都退出，所有的进程都退出以后，代码再向下执行
p.join()
print(‘asd’)
Process常用成员
name ：创建的子进程的名字
from multiprocessing import Process

import time

import os

def zjc(name):
print(“这是子进程%s，子进程的ID为：%d”%(name,os.getpid()))

if name == ‘main’:
print(“当前进程ID为：%d”%(os.getpid()))
p = Process(target=zjc,args=(‘asd’,),name=“asdasdasd”)
p.start()
p.join()
print(“子进程的名字为：%s%d”%(p.name,p.pid))
print(“game over”)

		time.sleep(2)  :  休眠两秒钟
	子类化Process  ：  就是将进程封装到类中
		from multiprocessing import Process

import os

import time

class MyProcess(Process):
def init(self,intval):
super().init()
self.intval = intval

def run(self):
    startTime = time.time()
    time.sleep(self.intval)
    endTime = time.time()
    print("子进程的ID为：%d，父进程的ID为：%d，创建进程所用时间为：%d"%(os.getpid(),os.getppid(),endTime-startTime))

if name == ‘main’:
head = time.time()
p = MyProcess(2)
p.start()
p.join()
foot = time.time()
t = foot - head
print(‘进程结束，所用时间%d秒’%(t))
创建多个进程
将实例化的过程循环展示
循环的方式打开进程
实例
from multiprocessing import Process

import os

import time

class MyProcess(Process):
def init(self,intval):
super().init()
self.intval = intval

def run(self):
    startTime = time.time()
    time.sleep(self.intval)
    endTime = time.time()
    print("子进程的ID为：%d，父进程的ID为：%d，创建进程所用时间为：%d"%(os.getpid(),os.getppid(),endTime-startTime))

if name == ‘main’:
head = time.time()
for i in range(5):
p = MyProcess(i+1)
p.start()
p.join()
foot = time.time()
t = foot - head
print(‘进程结束，所用时间%d秒’%(t))

	进程池
		进程的同步异步
			同步  ：  我们把异步环境下的一组并发进程因直接制约而互相发送消息、进行互相合作、互相等待，使得各进程按一定的速度执行的过程称为进程间的同步
			同步  ：  apply
			异步  ：  apply_async
			异步  ：  一个可以无需等待被调用函数的返回值就让操作继续进行的方法
			进程池的容量是3   但是我需要创建10个进程   同步需要一个一个创建    异步我可以直接不用等待   创建三个
		创建进程池
			导入包
				from  multiprocessing  import  Pool
				import  time
				import  os
			创建进程池，创建进程
			创建进程参数函数
			关闭资源，进程同步等
			实例
				from multiprocessing import Pool

import os

import time

#创建进程参数
def worker(msg):
print(“进程已经创建，进程的ID是%d”%os.getpid())
startTime = time.time()
time.sleep(2)
endTime = time.time()
print("====================进程已经结束，总共时长为%d秒"%(endTime-startTime))

#创建进程池
if name == ‘main’:
pool = Pool(3)
for i in range(10):
pool.apply_async(worker,(i,))

pool.close()
pool.join()
print("所有程序执行结束")

python知识点相关笔记

猜你喜欢