>

利用Hyperic调用Python完结进程守护

- 编辑:www.bifa688.com -

利用Hyperic调用Python完结进程守护

您可能感兴趣的文章:

  • Python多进程并发(multiprocessing)用法实例详解
  • 使用python 获取进程pid号的方法
  • 使用Python的Supervisor进行进程监控以及自动启动
  • python进程类subprocess的一些操作方法例子
  • 浅析Python中的多进程与多线程的使用
  • Python multiprocessing.Manager介绍和实例(进程间共享数据)
  • Python多进程通信Queue、Pipe、Value、Array实例
  • python开启多个子进程并行运行的方法
  • python关闭windows进程的方法
  • python 判断一个进程是否存在

主程序中这句tJoin = threading.Thread(target=join)执行后,只是创建了一个线程对象tJoin,但并未启动该线程。

Pool类中的map方法,与内置的map函数用法行为基本一致,它会使进程阻塞直到返回结果。
注意,虽然第二个参数是一个迭代器,但在实际使用中,必须在整个队列都就绪后,程序才会运行子进程。

调用操作系统方法获取进程信息,判断进程是否存在,Linux和Windows均支持,区别在于获取进程信息和启动进程的方法不同。

线程是一个进程的实体,是由表示程序运行状态的寄存器(如程序计数器、栈指针)以及堆栈组成,它是比进程更小的单位。
线程是程序中的一个执行流。一个执行流是由CPU运行程序代码并操作程序的数据所形成的。因此,线程被认为是以CPU为主体的行为。

该函数用于传递不定参数,主进程会被阻塞直到函数执行结束(不建议使用,并且3.x以后不在出现)。

#!/usr/bin/python
#-*- coding:utf-8 -*-

"""
名称:进程检查脚本
作者:wjzhu
时间:2014-06-30
功能:根据进程名称,判断进程是否存在,执行相应操作
参数:p_name:进程名称|p_path:进程启动路径
返回值:0:进程存在,正常退出|1:进程不存在,执行命令后,进程存在|2:其他异常情况

update:2014-07-29 启动进程前调用os.chdir()方法,改变当前工作目录,解决部分进程启动时依赖工作目录问题

"""

import os
import sys

#初始化进程名称和命令路径

#使用参数方式传递程序名称和程序路径
#p_name = sys.argv[1]
#p_path = sys.argv[2]

#Linux
p_name = "redis"
p_path = "/usr/local/redis-2.8.11/src/redis-server/usr/local/redis-2.8.11/redis.conf"

#Windows
#p_name = "filezilla.exe"
#p_path = "C:\Program Files (x86)\FileZilla FTP Client\filezilla.exe"



#Linux平台调用ps命令/Win平台调用tasklist命令,判断进程是否存在,传入进程名称,返回为查询得到的进程个数
def process_exit(process_name):
  #Linux
  p_checkresp = os.popen('ps aux | grep "'   process_name   '" | grep -v grep').readlines()

  #Windows,为避免进程名称被截断,输出格式为csv,使用tasklist /fo csv
  #p_checkresp = os.popen('tasklist /fo csv | find "'   process_name   '"').readlines()
  return len(p_checkresp)

#Linx平台调用os.system方法启动命令/Win平台调用os.startfile方法启动命令,传入命令路径,无返回值
def process_exec(process_path):
  #将工作目录切换到启动脚本所在目录,解决部分进程启动时依赖工作目录问题
  os.chdir(os.path.dirname(process_path))

  #Linxu
  os.system(process_path)

  #Windows
  #os.startfile(process_path)

#主函数
if __name__ == '__main__':

  #查询进程个数大于1,返回0,不做任何操作,退出
  if process_exit(p_name) >= 1:
    print 0
    sys.exit(0)

  #查询进程个数等于0
  elif process_exit(p_name) == 0:
    #执行启动命令
    process_exec(p_path)
    #查询进程个数大于1,返回1,启动成功,退出
    if process_exit(p_name) >= 1:
      print 1
      sys.exit(0)
    #启动失败,返回2,退出
    else:
      print 2
      sys.exit(0)

  #其他问题,返回2,退出
  else:
    print 2
    sys.exit(0)

执行结果:

程序中的r1表示全部进程执行结束后全局的返回结果集,run函数有返回值,所以一个进程对应一个返回结果,这个结果存在一个列表中,也就是一个结果堆中,实际上是用了队列的原理,等待所有进程都执行完毕,就返回这个列表(列表的顺序不定)。
对Pool对象调用join()方法会等待所有子进程执行完毕,调用join()之前必须先调用close(),让其不再接受新的Process了。

代码如下:

针对join()函数用法的实例:

close()

利用Hyperic调用Python,实现进程守护,供大家参考,具体内容如下

__init__(group=None, target=None, name=None, args=(), kwargs=None, verbose=None)

参数说明:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

一个线程本身不是程序,它必须运行于一个程序(进程)之中。因此,线程可以定义为一个程序中的单个执行流。

创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,并用其start()方法启动,这样创建进程比fork()还要简单。

多线程程序设计的含义就是可以将程序任务分成几个并行的子任务。

multiprocessing模块

isAlive():返回线程是否在运行。正在运行指的是启动后,终止前。

函数原型:

图片 1

#coding=utf-8
import multiprocessing

def do(n) :
 #获取当前线程的名字
 name = multiprocessing.current_process().name
 print name,'starting'
 print "worker ", n
 return

if __name__ == '__main__' :
 numList = []
 for i in xrange(5) :
  p = multiprocessing.Process(target=do, args=(i,))
  numList.append(p)
  p.start()
  p.join()
  print "Process end."
t.start()#启动线程

join()方法表示等待子进程结束以后再继续往下运行,通常用于进程间的同步。

参数说明:

在使用Python进行系统管理时,特别是同时操作多个文件目录或者远程控制多台主机,并行操作可以节约大量的时间。如果操作的对象数目不大时,还可以直接使用Process类动态的生成多个进程,十几个还好,但是如果上百个甚至更多,那手动去限制进程数量就显得特别的繁琐,此时进程池就派上用场了。

解析:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

多线程是指一个程序中包含多个执行流,多线程是实现并发的一种有效手段。一个进程在其执行过程中,可以产生多个线程,形成多个执行流。每个执行流即每个线程也有它自身的产生、存在和消亡的过程。

join()

t = Thread(target = run, args = ("this is a", "thread"))
import time
from multiprocessing import Pool
def run(fn):
 #fn: 函数参数是数据列表的一个元素
 time.sleep(1)
 return fn*fn

if __name__ == "__main__":
 testFL = [1,2,3,4,5,6] 
 print 'shunxu:' #顺序执行(也就是串行执行,单进程)
 s = time.time()
 for fn in testFL:
  run(fn)

 e1 = time.time()
 print "顺序执行时间:", int(e1 - s)

 print 'concurrent:' #创建多个进程,并行执行
 pool = Pool(5) #创建拥有5个进程数量的进程池
 #testFL:要处理的数据列表,run:处理testFL列表中数据的函数
 rl =pool.map(run, testFL) 
 pool.close()#关闭进程池,不再接受新的进程
 pool.join()#主进程阻塞等待子进程的退出
 e2 = time.time()
 print "并行执行时间:", int(e2-e1)
 print rl

通过继承Thread类

group:进程所属组。基本不用
target:表示调用对象。
args:表示调用对象的位置参数元组。
name:别名
kwargs:表示调用对象的字典。

图片 2

注意:

tContext = threading.Thread(target=context, args=(tJoin,))
tContext.start()
apply(func[, args=()[, kwds={}]])

thread模块是Python低版本中使用的,高版本中被threading代替了。threading模块提供了更方便的API来操作线程。

创建进程的简单实例:

线程的状态图:

1
34

2
5
time : 2.48600006104
# encoding: UTF-8
import threading
import time

def context(tJoin):
  print 'in threadContext.'
  tJoin.start()
  # 将阻塞tContext直到threadJoin终止。
  tJoin.join()
  # tJoin终止后继续执行。
  print 'out threadContext.'

def join():
  print 'in threadJoin.'
  time.sleep(1)
  print 'out threadJoin.'

tJoin = threading.Thread(target=join)
tContext = threading.Thread(target=context, args=(tJoin,))
tContext.start()

执行结果:

执行结果:

耗时不到1秒,可见多进程并发执行速度是很快的。

执行结果:

Process-1 starting
worker 0
Process end.
Process-2 starting
worker 1
Process end.
Process-3 starting
worker 2
Process end.
Process-4 starting
worker 3
Process end.
Process-5 starting
worker 4
Process end.

由于创建了两个并发执行的线程t1和t2,并发线程的执行时间不定,谁先执行完的时间也不定,所以执行后打印的结果顺序也是不定的。每一次执行都有可能出现不同的结果。

apply()

Thread类的构造方法:

在Windows上要想使用进程模块,就必须把有关进程的代码写在当前.py文件的if __name__ == ‘__main__' :语句的下面,才能正常使用Windows下的进程模块。Unix/Linux下则不需要。

执行结果:

再看一个实例:

import time
from multiprocessing.dummy import Pool as ThreadPool
#给线程池取一个别名ThreadPool
def run(fn):
 time.sleep(2)
 print fn

if __name__ == '__main__':
 testFL = [1,2,3,4,5]
 pool = ThreadPool(10)#创建10个容量的线程池并发执行
 pool.map(run, testFL)
 pool.close()
 pool.join()

并行处理某个目录下文件中的字符个数和行数,存入res.txt文件中,
每个文件一行,格式为:filename:lineNumber,charNumber

start():启动线程。

shunxu:
顺序执行时间: 6
concurrent:
并行执行时间: 2
[1, 4, 9, 16, 25, 36]

threading

上例是一个创建多个进程并发处理与顺序执行处理同一数据,所用时间的差别。从结果可以看出,并发执行的时间明显比顺序执行要快很多,但是进程是要耗资源的,所以平时工作中,进程数也不能开太大。

join([timeout]):阻塞当前上下文环境的线程,直到调用此方法的线程终止或到达指定的等待时间timeout(可选参数)。即当前的线程要等调用join()这个方法的线程执行完,或者是达到规定的时间。

map(func, iterable[, chunksize=None])

tJoin线程执行结束后,继续执行tContext线程,于是打印输出了out threadContext.,于是就看到我们上面看到的输出结果,并且无论执行多少次,结果都是这个顺序。但如果将context()函数中tJoin.join()这句注释掉,再执行该程序,打印输出的结果顺序就不定了,因为此时这两线程就是并发执行的。

进程实战实例

getName(name)/setName(name):获取/设置线程名。

与apply用法一样,但它是非阻塞且支持结果返回进行回调。

这句只是创建了一个线程,并未执行这个线程,此时线程处于新建状态。

再次执行结果如下:

这里的pool.map()函数,跟进程池的map函数用法一样,也跟内建的map函数一样。

执行结果:

multiprocessing.dummy

__init__(self, group=None, target=None, name=None, args=(), kwargs={})
in threadContext.
in threadJoin.
out threadJoin.
out threadContext.

您可能感兴趣的文章:

  • Python多进程库multiprocessing中进程池Pool类的使用详解
  • Python多进程multiprocessing用法实例分析
  • Python使用multiprocessing实现一个最简单的分布式作业调度系统
  • python基于multiprocessing的多进程创建方法
  • Python使用multiprocessing创建进程的方法
  • Python多进程并发(multiprocessing)用法实例详解
  • python使用multiprocessing模块实现带回调函数的异步调用方法
  • Python multiprocessing模块中的Pipe管道使用实例
  • Python标准库之多进程(multiprocessing包)介绍
  • Python multiprocessing.Manager介绍和实例(进程间共享数据)

group:线程组,目前还没有实现,库引用中提示必须是None。
target:要执行的方法;
name:线程名;
args/kwargs:要传入方法的参数。

主进程阻塞等待子进程的退出,join方法必须在close或terminate之后使用。

图片 3

multiprocessing包是Python中的多进程管理包。它与 threading.Thread类似,可以利用multiprocessing.Process对象来创建一个进程。该进程可以允许放在Python程序内部编写的函数中。该Process对象与Thread对象的用法相同,拥有is_alive()、join([timeout])、run()、start()、terminate()等方法。属性有:authkey、daemon(要通过start()设置)、exitcode(进程在运行时为None、如果为–N,表示被信号N结束)、name、pid。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类,用来同步进程,其用法也与threading包中的同名类一样。multiprocessing的很大一部份与threading使用同一套API,只不过换到了多进程的情境。

线程池实例:

Pool类

Thread类拥有的实例方法:

apply_async()

Thread是threading模块中最重要的类之一,可以使用它来创建线程。创建新的线程有两种方法:

terminate()

直接创建threading.Thread类的对象

import os
import time
from multiprocessing import Pool

def getFile(path) :
 #获取目录下的文件list
 fileList = []
 for root, dirs, files in list(os.walk(path)) :
  for i in files :
   if i.endswith('.txt') or i.endswith('.10w') :
    fileList.append(root   "\"   i)
 return fileList

def operFile(filePath) :
 #统计每个文件中行数和字符数,并返回
 filePath = filePath
 fp = open(filePath)
 content = fp.readlines()
 fp.close()
 lines = len(content)
 alphaNum = 0
 for i in content :
  alphaNum  = len(i.strip('n'))
 return lines,alphaNum,filePath

def out(list1, writeFilePath) :
 #将统计结果写入结果文件中
 fileLines = 0
 charNum = 0
 fp = open(writeFilePath,'a')
 for i in list1 :
  fp.write(i[2]   " 行数:"  str(i[0])   " 字符数:" str(i[1])   "n")
  fileLines  = i[0]
  charNum  = i[1]
 fp.close()
 print fileLines, charNum

if __name__ == "__main__":
 #创建多个进程去统计目录中所有文件的行数和字符数
 startTime = time.time()
 filePath = "C:\wcx\a"
 fileList = getFile(filePath)
 pool = Pool(5) 
 resultList =pool.map(operFile, fileList) 
 pool.close()
 pool.join()

 writeFilePath = "c:\wcx\res.txt"
 print resultList
 out(resultList, writeFilePath)
 endTime = time.time()
 print "used time is ", endTime - startTime
  • thread(低版本使用的),threading
  • Queue
  • multiprocessing
21

3
4
5
time : 2.51999998093

以上就是本文关于Python多线程threading和multiprocessing模块实例解析的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

看一下Process类的构造方法:

注意:

结束工作进程,不在处理未处理的任务。

实例:

关闭进程池(pool),使其不在接受新的任务。

Python中线程multiprocessing模块与进程使用的同一模块。使用方法也基本相同,唯一不同的是,from multiprocessing import Pool这样导入的Pool表示的是进程池;
from multiprocessing.dummy import Pool这样导入的Pool表示的是线程池。这样就可以实现线程里面的并发了。

map()

in threadJoin.
out threadJoin.

这个模块表示像线程一样管理进程,这个是multiprocessing的核心,它与threading很相似,对多核CPU的利用率会比threading好的多。

  • 方法一:直接创建threading.Thread类的对象,初始化时将可调用对象作为参数传入。
  • 方法二:通过继承Thread类,重写它的run方法。

结果中为什么还有空行和没有折行的数据呢?其实这跟进程调度有关,当有多个进程并行执行时,每个进程得到的时间片时间不一样,哪个进程接受哪个请求以及执行完成时间都是不定的,所以会出现输出乱序的情况。那为什么又会有没这行和空行的情况呢?因为有可能在执行第一个进程时,刚要打印换行符时,切换到另一个进程,这样就极有可能两个数字打印到同一行,并且再次切换回第一个进程时会打印一个换行符,所以就会出现空行的情况。

启动线程,此时线程扔为运行,只是处于准备状态。

multiprocessing.Pool类的实例:

继承Thread类的新类MyThread构造函数中必须要调用父类的构造方法,这样才能产生父类的构造函数中的参数,才能产生线程所需要的参数。新的类中如果需要别的参数,直接在其构造方法中加即可。

apply_async(func[, args=()[, kwds={}[, callback=None]]])

注意:

Pool类可以提供指定数量的进程供用户调用,当有新的请求提交到Pool中时,如果池还没有满,就会创建一个新的进程来执行请求。如果池满,请求就会告知先等待,直到池中有进程结束,才会创建新的进程来执行这些请求。
下面介绍一下multiprocessing 模块下的Pool类下的几个方法

本文研究的主要是Python多线程threading和multiprocessing模块的相关内容,具体介绍如下。

执行结果:

线程是一个用户级的实体,线程结构驻留在用户空间中,能够被普通的用户级函数直接访问。

函数原型:

同时,新类中,在重写父类的run方法时,它默认是不带参数的,如果需要给它提供参数,需要在类的构造函数中指定,因为在线程执行的过程中,run方法时线程自己去调用的,不用我们手动调用,所以没法直接给传递参数,只能在构造方法中设定好参数,然后再run方法中调用。

import time
from multiprocessing import Pool
def run(fn) :
 time.sleep(2)
 print fn
if __name__ == "__main__" :
 startTime = time.time()
 testFL = [1,2,3,4,5]
 pool = Pool(10)#可以同时跑10个进程
 pool.map(run,testFL)
 pool.close()
 pool.join()  
 endTime = time.time()
 print "time :", endTime - startTime

上面这两句执行后,创建了另一个线程对象tContext并启动该线程(打印in threadContext.),同时将tJoin线程对象作为参数传给context函数,在context函数中,启动了tJoin这个线程,同时该线程又调用了join()函数(tJoin.join()),那tContext线程将等待tJoin这线程执行完成后,才能继续tContext线程后面的,所以先执行join()函数,打印输出下面两句:

图片 4

from threading import Thread
import time

class MyThread(Thread) :
 def __init__(self, a) :
  super(MyThread, self).__init__()
  #调用父类的构造方法
  self.a = a

 def run(self) :
  print "sleep :", self.a
  time.sleep(self.a)

t1 = MyThread(2)
t2 = MyThread(4)
t1.start()
t2.start()
t1.join()
t2.join()

执行结果:

您可能感兴趣的文章:

  • Python线程创建和终止实例代码
  • Python实现可设置持续运行时间、线程数及时间间隔的多线程异步post请求功能
  • Python基于ThreadingTCPServer创建多线程代理的方法示例
  • Python之多线程爬虫抓取网页图片的示例代码
  • Python3多线程爬虫实例讲解代码
  • python回调函数中使用多线程的方法
  • Python多线程爬虫实战_爬取糗事百科段子的实例
  • python编程测试电脑开启最大线程数实例代码

函数原型:

isDaemon(bool)/setDaemon(bool):获取/设置是否为守护线程。初始值从创建该线程的线程继承而来,当没有非守护线程仍在运行时,程序将终止。

总结

from threading import Thread
import time
def run(a = None, b = None) :
 print a, b 
 time.sleep(1)

t = Thread(target = run, args = ("this is a", "thread"))
#此时线程是新建状态

print t.getName()#获得线程对象名称
print t.isAlive()#判断线程是否还活着。
t.start()#启动线程
t.join()#等待其他线程运行结束

threading.Thread

自定义函数run(),使我们自己根据我们需求自己定义的,函数名可以随便取,run函数的参数来源于后面的args元组。

Thread-1
False
this is a thread

线程不包含进程地址空间中的代码和数据,线程是计算过程在某一时刻的状态。所以,系统在产生一个线程或各个线程之间切换时,负担要比进程小得多。

Python中常使用的线程模块

实例:

本文由必发88手机版发布,转载请注明来源:利用Hyperic调用Python完结进程守护