python 进程的一些其他方法

 OK通过上面两篇的内容,对进程有了一个初步的认识     进程 就是一个方法,就跟面相对象,函数一样,都是python中的方法,为了能够

让自己程序更有效率.     上两篇就是告诉大家,进程的一个样子,怎样的一个书写格式,   大家只要记住格式是什么,会用就可以了,   进程的那些概念的东西,

大家可以没事上百度,了解一下就可以了.

话不多说,接下来就是   进程 的一些使用方法

import  os                                                       #这次我们倒入一个os模块     待会查看一下进程id                    
from  multiprocessing   import   Process

def  f1():
  print(‘子进程的pid‘,os.getpid())                  #os.getpid()是获取进程id 的
  print(‘子进程的父进程的pid‘,os.getppid())          #os.getppid()  是获取在子进程中父进程的进程id

                        #仔细看这两个方法不一样
  print(‘aaa‘)

def  f2():
  print(‘bbb‘)

if __name__ == ‘__main__‘:

  p1 = Process(target=f1,name=‘宝宝1‘)
  p2 = Process(target=f2,)
  p1.start()
  p2.start()
  print(p1.name)                                     #查看进程传参的属性   也就是宝宝1    没啥意思这个功能
  print(‘子进程的pid‘,p1.pid)                              #  获取子进程进程id
  print(‘父进程的id‘,os.getpid())        #获取父进程的id

最后打印完结果,你就会发现,所有的父进程是同一个id,,,所有子进程是同一个id,       这就说明子进程跟父进程是两个id,不是一起的..稍微记住

from  multiprocessing   import   Process

def   f1():
  print(‘子进程1号‘)

if __name__ == ‘__main__‘:
  p = Process(target=f1,)
  p.start()

  print(p.is_alive())            #判断子进程是否还活着,是否还在运行,   如果子进程还会运行会

                      反回一个True
  p.terminate()              #给操作系统发送一个结束进程的信号,然后操作系统帮他结束进程
  print(p.is_alive())              #结束了进程,再查看的子进程是否还在运行,这时候就会返回False

既然不是一个id的,那么是否是一个空间的呢?

from  mulitiprocessing   import  Process

num = 100                                          #这是全局变量这个大家都知道吧  ,那么接下来的几行注释就是打印结果

def  f1():

  global   num

  num = 3

  print("子进程中的num")          #  结果 3

print(num)             #结果100   先说一下这里是两个一百,首先是先打印一个全局变量100

                 #等执行子进程的时候,子进程会把父进程的内容复制一遍,再次打印父进程内容

                 #所以就是两个100

if __name__=="__main__":

  p = Process(target = f1,)

  p.start()

  p.join()

  print("主进程中的num",num)   #结果100

最后结果就是   发现父进程是全局空间,子进程是局部空间   ,子进程再怎么global改变全局变量,父进程里的

num都没变,父进程永远都是一个空间,子进程是一个空间,那么子进程再怎么修改自己所在的空间里的num,父进程

所在的空间的num都没变,      这俩的空间跟全局,局部没任何关系,这块有点抽象,大家理解一下.

所以子进程跟父进程之间是空间隔离的.

守护进程:

import time
from  multiprocessing  import  Process

def   f1():

  time.sleep(3)
  print(‘xxxx‘)

def   f2():

  time.sleep(5)
  print(‘普通子进程的代码‘)
if __name__ == ‘__main__‘:
  p = Process(target=f1,)
  p.daemon = True                             #这个就是守护进程  ,p.daemon = True  将该进程设置为守护进程,必须写在start之前,意思如果我的主进程代码运行结束了,你这个子进程不管运行到什么地方,都直接结束

  p.start()

  p2 = Process(target=f2,)
  p2.start()

  p2.join()

  print(‘主进程结束‘)

这个最后打印完了就是先打印主进程"主进程结束"  再打印p2结果,p1不打印,这就是守护进程

开启一个普通的子进程来验证一下守护进程的结束只和主进程的代码运行结束有关系,而整个程序的结束需要主进程和普通的子进程的代码都运行结束才结束

守护进程会跟跟着父进程的代码运行结束,就结束

但如果加上时间就不一样了

如果p1时间比p2时间短 ,p2中间加一个阻隔的话join(),先不打印父进程,打印子进程,的话,那么守护进程时间快

守护进程也就被打印了.所以而整个程序的结束需要主进程和普通的子进程的代码都运行结束才结束

守护进程会跟跟着父进程的代码运行结束,就结束

好好理解一下,打印一下,很简单的.

互斥锁,同步锁,进程锁       跟  数据共享

首先呀      互斥锁,同步锁,进程锁     这三个锁是同一个锁,只不过是三种叫法   ,不必纠结 ,叫什们都行                              
import time
from multiprocessing import Process,Manager,Lock

def   f1(m_d,l2):                      #OK 方法能先说一下,锁是Lock,     数据共享是Manager
  with l2:               #with l2   是锁的 一种简写   ,直接with锁的对象,就把内容锁住了
    #l2.acquire()                 #这个就是锁的原来的样子了,先锁住
    tmp = m_d[‘num‘]       # 中间这段代码,是执行的内容,大家看一下咋回事就行,
    tmp -= 1
    time.sleep(0.1)
    m_d[‘num‘] = tmp
    # l2.release()         #再开锁  ,这就是锁的写法

if __name__ == ‘__main__‘:
  m = Manager()          #这个呢是数据共享,然后创建一个对象 m  随便定义一个变量  
  l2 = Lock()
  m_d = m.dict({‘num‘:100})     #然后传共享参数,就跟小黄车一样哈,虽然小黄车快黄了
  p_list = []
  for i in range(10):         #创建10个进程       
    p = Process(target=f1,args=(m_d,l2))    把共享属性传上去
    p.start()
    p_list.append(p)       #为什们要加进一个列表里面呢,是因为,我们要统一把10个进程

  [pp.join() for pp in p_list]      #都加上join(),一是内容需要,另一个就是,当我们创建很多个进程

  print(m_d[‘num‘])          #的时候,操作顺序不是我们能决定的,是操作系统来决定的,不加

                  #join的话,说不好他先操作那个进程,那不就乱了套了吗,所以每个都加上join   ,这样10个进程都能按顺序操作了.这是个很重要的一个知识点,一定要   记住了....

锁呢是将10个进程一个一个的锁住,打印的时候不乱套,要不然都进来的话数据内容就乱了

这块跟join() 有点绕.join是让操作系统  一个一个排序的进行进程操作,  而锁呢是将进程内容给锁起来,让内容

一个一个操作,锁是跟进程内容有关.

数据共享就是10个进程,都能用这个属性

队列:

from multiprocessing import Process,Queue

q = Queue(3)       #创建一个队列对象,队列长度为3,先进先出
q.put(1)         #输入内容

# print(‘>>>>>‘,q.qsize())     #返回当前队列的内容长度
print(q.full())        #查看队列是否都满了没满就返回False
q.put(2)

# print(‘>>>>>‘,q.qsize())
q.put(3)
print(q.full())

print(q.get())            #打印内容
print(q.get())
print(q.get())
print(‘是不是空了呀:‘,q.empty())

队列大家打印一下,就可以了

for 循环

又来一个for循环,这个就是为了让所有的所有的进程加join的,哈哈哈..看下数据共享跟锁

那块的那段话就知道了..

import time
from multiprocessing import Process

def   f1():
  time.sleep(0.5)
  print(‘xxx‘)

if __name__ == ‘__main__‘:
  p_list = []
#for循环创建子进程,并且完成主进程等待所有子进程执行结束,才继续执行
  for i in range(10):
    p = Process(target=f1,)
    p.start()
    p_list.append(p)
    p.join()
  [pp.join() for pp in p_list]

  print(‘主进程结束‘)

OK  东西有点多,不过都是一些方法而已大框没变,里边加东西就可以了

大家好好记一下,练一下,记住多练就好了.

原文地址:https://www.cnblogs.com/python-lyy/p/10264363.html

时间: 2024-10-18 15:56:58

python 进程的一些其他方法的相关文章

python进程创建过程和方法

#multiprocess.process模块 #process模块是一个创建进程的模块,借助这个模块,可以完成进程的创建 # Process([group[,target[,name[,args[,kwargs]]]]]) ,由该实例化得到的对象, # 表示一个子进程的任务(尚未启动) #注意(参数介绍): #1.需要使用关键字参数的方式来指定参数 #2.args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号 #3.group参数为使用,值始终未None #4.target

python 进程内存增长问题, 解决方法和工具

python 进程内存增长问题, 解决方法和工具 表现 解决方法 定位问题过程 gdb-python: 搞清楚python程序在做什么 准备gdb 接入gdb 查看线程 查看调用栈 coredump 其他命令 pyrasite: 连接进入python程序 psutil 查看python进程状态 guppy 取得内存使用的各种对象占用情况 无法回收的对象 不可回收对象的例子 ?? objgraph 查找循环引用 表现 运行环境: # uname -a Linux ** 3.10.0-327.el7

python开启进程的两种方法

1.开启进程的方法一 from multiprocessing import Process import time def work(name): #定义一个函数 print('task <%s> is runing' %name) time.sleep(1) print('task <%s> is aaaaa' %name) if __name__ == '__main__': p1=Process(target=work,args=('yxwang',)) #产生一个进程对象

python进程池剖析(一)

python中两个常用来处理进程的模块分别是subprocess和multiprocessing,其中subprocess通常用于执行外部程序,比如一些第三方应用程序,而不是Python程序.如果需要实现调用外部程序的功能,python的psutil模块是更好的选择,它不仅支持subprocess提供的功能,而且还能对当前主机或者启动的外部程序进行监控,比如获取网络.cpu.内存等信息使用情况,在做一些自动化运维工作时支持的更加全面.multiprocessing是python的多进程模块,主要

python进程池剖析(二)

之前文章中介绍了python中multiprocessing模块中自带的进程池Pool,并对进程池中的数据结构和各个线程之间的合作关系进行了简单分析,这节来看下客户端如何对向进程池分配任务,并获取结果的. 我们知道,当进程池中任务队列非空时,才会触发worker进程去工作,那么如何向进程池中的任务队列中添加任务呢,进程池类有两组关键方法来创建任务,分别是apply/apply_async和map/map_async,实际上进程池类的apply和map方法与python内建的两个同名方法类似,ap

Python进程

Python在2.6引入了多进程的机制,并提供了丰富的组件及api以方便编写并发应用.multiprocessing包的组件Process, Queue, Pipe, Lock等组件提供了与多线程类似的功能.使用这些组件,可以方便地编写多进程并发程序. 多进程实例: import osfrom multiprocessing import Process def info(title):    print(title)    print('module name:', __name__)    

Python编程(二):Python进程、线程那点事儿

多进程,多线程编程 系统程序员.运维开发程序员在面试的时候经常会被问及一个常见问题: 进程是什么,线程是什么,进程和线程有什么区别? 不得不承认,这么多年了.这个问题依旧是个很难以招架的问题,简单地说: 进程和线程有很多类似的性质,他们都可以被CPU作为一个单元进行调度,他们都拥有自己独立的栈(stack)等等.因此线程也被称作LWP(Lightweight Process,轻量级进程):对应的进程也可以被称作为HWP(Heavyweight Process,重量级进程),从线程的角度看,进程就

python进程、线程、协程

进程与线程的历史 我们都知道计算机是由硬件和软件组成的.硬件中的CPU是计算机的核心,它承担计算机的所有任务. 操作系统是运行在硬件之上的软件,是计算机的管理者,它负责资源的管理和分配.任务的调度. 程序是运行在系统上的具有某种功能的软件,比如说浏览器,音乐播放器等. 每次执行程序的时候,都会完成一定的功能,比如说浏览器帮我们打开网页,为了保证其独立性,就需要一个专门的管理和控制执行程序的数据结构--进程控制块. 进程就是一个程序在一个数据集上的一次动态执行过程. 进程一般由程序.数据集.进程控

Python 进程池

一.定义: 多进程是实现并发的手段之一,在利用Python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并行操作可以节约大量的时间.                  Pool([numprocess [,initializer [, initargs]]]):创建进程池 二.主要参数: 1 numprocess:要创建的进程数,如果省略,将默认使用cpu_count()的值 2 initializer:是每个工作进程启动时要执行的可调用对象,默认为None 3 init