[保留] Python做cpu利用率的脚本 - ChinaUnix.net
[保留] Python做cpu利用率的脚本
http://www.chinaunix.net 作者:&&发表于： 14:53:53
谁有现成的么？刚接到任务做这个，对python也不熟，帮个忙。
& 回复于： 15:52:59
给你两个链接参考下把
http://blog.csdn.net/ustclu/archive//1721673.aspx
http://topic.csdn.net/u//2765EDE0-B120-4BB8-8481-CF2A09AE0D57.html
是linux下的
& 回复于： 17:04:44
:mrgreen:&
多谢xiaoyu9805119&&&&
看来还是得使用/proc/stat&自己来解析好了
& 回复于： 14:53:06
经过1天的努力，还是勉强完成了cpu利用率的统计，贴出来，希望对后来这有些帮助：
里面的sendlog大家可以不用，这是我发送日志到特定的日志服务器统一处理的。
在Linux系统中，可以用/proc/stat文件来计算cpu的利用率(详细的解释可参考：http:&//www.linuxhowtos.org/System/procstat.htm)。这个文件包含了所有CPU活动的信息，该文件中的所有值都是从系统启动开始累计到当前时刻。&
如：&
[sailorhzr@builder&~]$&cat&/proc/stat&
cpu&95&968&&5346&
cpu0&2&694&5&
cpu1&4&820&1&
cpu2&4&167&4&
cpu3&&285&&
intr&&&92&0&6&6&0&4&0&&0&70&0&20&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&&0&0&0&0&0&0&&0&0&0&0&0&0&30&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&
ctxt&&
btime&&
processes&270014&
procs_running&1&
procs_blocked&0&
输出解释&
CPU&以及CPU0、CPU1、CPU2、CPU3每行的每个参数意思（以第一行为例）为：&
参数&解释&
user&(432661)&从系统启动开始累计到当前时刻，用户态的CPU时间（单位：jiffies）&，不包含&nice值为负进程。1jiffies=0.01秒&
nice&(13295)&从系统启动开始累计到当前时刻，nice值为负的进程所占用的CPU时间（单位：jiffies）&
system&(86656)&从系统启动开始累计到当前时刻，核心时间（单位：jiffies）&
idle&()&从系统启动开始累计到当前时刻，除硬盘IO等待时间以外其它等待时间（单位：jiffies）&
iowait&(171474)&从系统启动开始累计到当前时刻，硬盘IO等待时间（单位：jiffies）&，&
irq&(233)&从系统启动开始累计到当前时刻，硬中断时间（单位：jiffies）&
softirq&(5346)&从系统启动开始累计到当前时刻，软中断时间（单位：jiffies）&
CPU时间=user+system+nice+idle+iowait+irq+softirq&
“intr”这行给出中断的信息，第一个为自系统启动以来，发生的所有的中断的次数；然后每个数对应一个特定的中断自系统启动以来所发生的次数。&
“ctxt”给出了自系统启动以来CPU发生的上下文交换的次数。&
“btime”给出了从系统启动到现在为止的时间（in&seconds&since&the&Unix&epoch），单位为秒。&
“processes&(total_forks)&自系统启动以来所创建的任务的个数目。&
“procs_running”：当前运行队列的任务的数目。&
“procs_blocked”：当前被阻塞的任务的数目。&
那么CPU利用率可以使用以下两个方法(后一种比较准确)。先取两个采样点，然后计算其差值：&
cpu&usage=(idle2-idle1)/(cpu2-cpu1)*100&
cpu&usage=[(user_2&+sys_2+nice_2)&-&(user_1&+&sys_1+nice_1)]/(total_2&-&total_1)*100&
import&sys&
import&re
import&time&
from&scribe&import&scribe
from&thrift.transport&import&TTransport,&TSocket
from&thrift.protocol&import&TBinaryProtocol
&
def&read_cpu_usage():&
&&&&"""Read&the&current&system&cpu&usage&from&/proc/stat."""&
&&&&lines&=&open("/proc/stat").readlines()&
&&&&for&line&in&lines:&
&&&&&&&&#print&"l&=&%s"&%&line&
&&&&&&&&l&=&line.split()&
&&&&&&&&if&len(l)&&&5:&
&&&&&&&&&&&&continue&
&&&&&&&&if&l[0].startswith('cpu'):&
&&&&&&&&&&&&return&l;
&&&&return&{}&
&
def&sendlog(host,port,messa):
&&&&#"""send&log&to&scribe
&&&&socket&=&TSocket.TSocket(host=host,&port=port)
&&&&transport&=&TTransport.TFramedTransport(socket)
&&&&protocol&=&TBinaryProtocol.TBinaryProtocol(trans=transport,&strictRead=False,&strictWrite=False)
&&&&client&=&scribe.Client(iprot=protocol,&oprot=protocol)
&&&&transport.open()
&&&&log_entry&=&scribe.LogEntry(dict(category='SYSD',&message=messa))
&&&&result&=&client.Log(messages=[log_entry])
&&&&transport.close()
&&&&return&result
if&len(sys.argv)&&=&2:
&&host_port&=&sys.argv[1].split(':')
&&host&=&host_port[0]
&&if&len(host_port)&&&1:
&&&&port&=&int(host_port[1])
&&else:
&&&&port&=&1463
else:
&&sys.exit('usage&:&py.test&&host[:port]]&')
cpustr=read_cpu_usage()
down=True
#cpu&usage=[(user_2&+sys_2+nice_2)&-&(user_1&+&sys_1+nice_1)]/(total_2&-&total_1)*100&
usni1=long(cpustr[1])+long(cpustr[2])+long(cpustr[3])+long(cpustr[5])+long(cpustr[6])+long(cpustr[7])+long(cpustr[4])
usn1=long(cpustr[1])+long(cpustr[2])+long(cpustr[3])
#usni1=long(cpustr[1])+long(cpustr[2])+long(cpustr[3])+long(cpustr[4])
while(down):
&&&&&&&time.sleep(2)
&&&&&&&cpustr=read_cpu_usage()
&&&&&&&usni2=long(cpustr[1])+long(cpustr[2])+float(cpustr[3])+long(cpustr[5])+long(cpustr[6])+long(cpustr[7])+long(cpustr[4])
&&&&&&&usn2=long(cpustr[1])+long(cpustr[2])+long(cpustr[3])
&&&&&&&#usni2=long(cpustr[1])+long(cpustr[2])+float(cpustr[3])+long(cpustr[4])
&&&&&&&print&usn2
&&&&&&&print&usni2
&&&&&&&cpuper=(usn2-usn1)/(usni2-usni1)
&&&&&&&s="CPUTotal&used&percent&=%.4f&\r\n"&%&cpuper
&&&&&&&print&s
&&&&&&&sendlog(host,port,s)
&&&&&&&usn1=usn2
&&&&&&&usni1=usni2
[&本帖最后由&zlzj2010&于&&14:58&编辑&]
& 回复于： 14:53:53
原文链接：
转载请注明作者名及原文出处Parallel Python实现python程序的并行及多cpu多核利用 - 推酷
Parallel Python实现python程序的并行及多cpu多核利用
为啥要这个模块：
Python是解释型的语言,而Python解释器使用GIL(全局解 释器锁)来在内部禁止并行执行,正是这个GIL限制你在多核处理器上同一时间也只能执行一条字节码指令. 听朋友说python 3.0 里面已经改进, 默认有了多处理器编程的库了. Python2.XX暂时还不支持。
Parallel Python 这个库,正是为支持smp多路多核多cpu而设计的, 而且它不仅可以多核处理器协同工作,还可以通过网络集群运行。
pp模块的简介
PP 是一个Python模块，提供了在SMP(多CPU或多核)和集群(通过网络连接的多台计算机)上并行执行Python代码的机制。轻量级，易于安装，并 集成了其他软件。PP也是一个用纯Python代码实现的跨平台，开放源码模块。
下面是看起来很高端的功能介绍 ！
* 在SMP和集群上并行执行Python代码
* 易于理解和实现的基于工作的并行机制，便于把穿行应用转换成并行的
* 自动构造最佳配置(默认时工作进程数量等同于系统处理器数量)
* 动态处理器分配(允许运行时改变工作处理器数量)
* 函数的工作缓存(透明的缓存机制确保后续调用降低负载)
* 动态负载均衡(任务被动态的分配到各个处理器上)
* 基于SHA的连接加密认证
* 跨平台移植(Windows/Linux/Unix)
* 开放源代码
有些朋友可能对并发和并行理解有点乱，在这里梳理下哈：
当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状态.这种方式我们称之为并发(Concurrent).
当系统有一个以上CPU时,则线程的操作有可能非并发.当一个CPU执行一个线程时,另一个CPU可以执行另一个线程,两个线程互不抢占CPU资源,可以同时进行,这种方式我们称之为并行(Parallel)
多线程在并发和并行环境中的不同作用
在并发环境时,多线程不可能真正充分利用CPU,节约运行时间,它只是以”挂起-&执行-&挂起”的方式以很小的时间片分别运行各个线程,给用户以每个线程都在运行的错觉.在这种环境中,多线程程序真正改善的是系统的响应性能和程序的友好性.
在并行环境中, 一个时刻允许多个线程运行,这时多线程程序才真正充分利用了多CPU的处理能力, 节省了整体的运行时间.在这种环境中,多线程程序能体现出它的四大优势:充分利用CPU,节省时间,改善响应和增加程序的友好性.
并发和并行的区别就是一个处理器同时处理多个任务和多个处理器或者是多核的处理器同时处理多个不同的任务。
前者是逻辑上的同时发生（simultaneous），而后者是物理上的同时发生．
来个比喻：并发和并行的区别就是一个人同时吃三个馒头和三个人同时吃三个馒头。
咱们跑一下：
安装pp模块
650) this.width=650;" src="/jYJVz2.jpg!web" title="pp1.jpg" alt="wKioL1L0oR2DYbzBAASEU-Qi-d4142.jpg" />
好，测试 ！！！
【这是单核的利用情况下】
650) this.width=650;" src="/Vf2IRvj.jpg!web" title="pp2.jpg" alt="wKiom1L0oXHhkVSXAAMhQfNWcTQ565.jpg" />
开启python多核的情况下
【看到没有，多出了4个进程，这四个进程是绑在不同的cpu上，这四个cpu跑的很均匀】
650) this.width=650;" src="/aEz6Ff.jpg!web" title="pp3.jpg" alt="wKioL1L0oYTwZasxAAOB_6sZyGw395.jpg" />
测试的代码：
#-*- coding: UTF-8 -*-
import math, sys, time
def IsPrime(n):
&&&返回n是否是素数&&&
if not isinstance(n, int):
raise TypeError(&argument passed to is_prime is not of 'int' type&)
return False
if n == 2:
return True
max = int(math.ceil(math.sqrt(n)))
while i &= max:
if n % i == 0:
return False
return True
def SumPrimes(n):
for i in xrange(15):
sum([x for x in xrange(2,n) if IsPrime(x)])
&&&计算从2-n之间的所有素数之和&&&
return sum([x for x in xrange(2,n) if IsPrime(x)])
inputs = (, , 0700)
start_time = time.time()
for input in inputs:
print SumPrimes(input)
print '单线程执行，总耗时', time.time() - start_time, 's'
# tuple of all parallel python servers to connect with
ppservers = ()
#ppservers = (&10.0.0.1&,)
if len(sys.argv) & 1:
ncpus = int(sys.argv[1])
# Creates jobserver with ncpus workers
job_server = pp.Server(ncpus, ppservers=ppservers)
# Creates jobserver with automatically detected number of workers
job_server = pp.Server(ppservers=ppservers)
print &pp 可以用的工作核心线程数&, job_server.get_ncpus(), &workers&
start_time = time.time()
jobs = [(input, job_server.submit(SumPrimes,(input,), (IsPrime,), (&math&,))) for input in inputs]
for input, job in jobs:
print &Sum of primes below&, input, &is&, job()
print &多线程下执行耗时: &, time.time() - start_time, &s&
job_server.print_stats()
pp的官方例子给的很足，也相当的简练 ！
导入让python支持多核心的模块
1) Import pp module:
& &import pp
一个实例，含有cpu的核心数目
2) Start pp execution server with the number of workers set to the number of processors in the system
& &job_server = pp.Server()
可以支持网络的分布式运算 ！
# tuple of all parallel python servers to connect with
ppservers = ()
#ppservers = (&10.0.0.1&,)
ncpus = int(sys.argv[1])
# Creates jobserver with ncpus workers
job_server = pp.Server(ncpus, ppservers=ppservers)
3) Submit all the tasks for parallel execution:
& &f1 = job_server.submit(func1, args1, depfuncs1, modules1)
& &f2 = job_server.submit(func1, args2, depfuncs1, modules1)
& &f3 = job_server.submit(func2, args3, depfuncs2, modules2)
& ...etc...
4) Retrieve the results as needed:
& &r1 = f1()
& &r2 = f2()
& &r3 = f3()
& &...etc...
刚才说了 parallet python 是支持网络的分布式运算集群的 ！
Advanced guide, clusters
On the nodes &
1) Start parallel python execution server on all your remote computational nodes (listen to a given port 35000,
and local network interface only, accept only connections which know correct secret):
& &node-1& ./ppserver.py -p 35000 -i 192.168.0.101 -s &mysecret&
& &node-2& ./ppserver.py -p 35000 -i 192.168.0.102 -s &mysecret&
& &node-3& ./ppserver.py -p 35000 -i 192.168.0.103 -s &mysecret&
On the client
2) Import pp module:
& &import pp
3) &Create a list of all the nodes in your cluster (computers where you've run ppserver.py)
& &ppservers=(&node-1:35000&, &node-2:35000&, &node-3:35000&)
4) Start pp execution server with the number of workers set to the number of processors in the system,
list of ppservers to connect with and secret key to authorize the connection:
& &job_server = pp.Server(ppservers=ppservers, secret=&mysecret&)
5) Submit all the tasks for parallel execution:
& &f1 = job_server.submit(func1, args1, depfuncs1, modules1)
& &f2 = job_server.submit(func1, args2, depfuncs1, modules1)
& &f3 = job_server.submit(func2, args3, depfuncs2, modules2)
& ...etc...
6) Retrieve the results as needed:
& &r1 = f1()
& &r2 = f2()
& &r3 = f3()
& &...etc...
7) Print the execution statistics:
& &job_server.print_stats()
650) this.width=650;" src="/EjuQby.jpg!web" title=" 17:22:37的屏幕截图.png" alt="wKioL1L0pg3wgnTFAAXZt2-zTng198.jpg" />
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致说三道四技术文摘-感悟人生的经典句子
> 文档快照
我开始并没有说清楚，这里指的CPU是多核CPU，所有的语言都只有一个进程。java，python程序开多线程。PythonLinuxJava安江泽，爱折腾假设同样的业务，不同语言的实现，基于多线程的架构，任务是计算密集的。这种情况Python的GlobalIntepreterLock会阻碍程序充分利用CPU资源，不管使
我开始并没有说清楚，这里指的CPU是多核CPU，所有的语言都只有一个进程。java，python程序开多线程。 PythonLinuxJava安江泽，爱折腾假设同样的业务，不同语言的实现，基于多线程的架构，任务是计算密集的。这种情况Python的Global Intepreter Lock会阻碍程序充分利用CPU资源，不管使用多少线程，同一时间只有一个线程在进行计算工作，其他线程处在等待切换的状态。 彭哲夫，么么哒我不知道为嘛大家总是认为Python因为GIL不能利用多线程，GIL其实是个很粗颗粒状态的线程安全机制，有了GIL线程不一定安全，不然thread的模块就不用提供锁了。只能说在某些情况下GIL会起到应有的作用，但没了GIL，完全交给程序员去控制锁似乎又回到了C/CPP的状态。实际项目中，多进程配合微线程（Greenlet/Gevent）是可以完全利用现在多核CPU资源的，要不就写C扩展。写Python C代码中有个Py_BEGIN_ALLOW_THREADS和Py_END_ALLOW_THREADS就是干这活的（http://docs.python.org/c-api/init.html），所以有些C库能避免GIL而在多线程环境下完全利用CPU资源，比如pylibmc。 Saber，技术，幽默python里的多线程是单cpu意义上的多线程，它和多cpu上的多线程有着本质的区别。单cpu多线程：并发多cpu多线程：并行内部包含并发在python当中，存在一个叫Global Interpreter Lock(GIL)的东西，直译就是全局解释器锁。它的作用在于让同一时刻只能有一个线程对于python对象进行操作。Python已经提供了各种机制让我们进行多线程同步，为什么又要整这个GIL呢？这是因为程序员控制的同步是对各个程序中可见的变量，而GIL同步的是解释器后台的不可见变量，比如为了进行垃圾回收而维护的引用计数。如果没有GIL，有可能出现由于线程切换导致的对同一个对象释放两次的情况。因此，任何一个CPython线程如果要执行，就必须先获取这个GIL。后果？就是在CPython中，本质上几乎是没有线程并行的，不论你开多少个线程，同一时刻只有获取GIL的那个线程能够执行java，就不说了。开始设计就要求是多线程的,而且java的多线程是java不能实现完整跨平台一个重要因素（线程的优先级在不同操作系统表现的不一样） 董诣，工程师python用多进程方式也可以把cpu跑满 韩孟岗，to be devops ...“多核 CPU 、Linux 操作系统下为什么 Java 可以将 CPU 都占满，而 php、Python 等不行？”其实这个题目没有提到Python程序如何运行的。如果是任务本身是计算密集型的，使用php，python各开发一个应用。每个应用都运行多个实例（进程），比如10个进程，也可以把CPU跑满。 蒋长生，工程师python可以用C扩展的方式将CPU跑满 翅膀，java,篮球,游泳,汽车,看书,电影,动画,游戏把cpu跑满难道是个评价体系里的某个指标?赵春阳，我是来学习的for($a=1;$a&0;$a++){
$a+2;}看看能不能跑满Blues，一小小创业网络创业公司CTO...我这PHP经常把CPU跑满,所以具体得看代码,是什么限制了性能 Tony lee，Program architect @douban多进程，多实例密集型计算，进程频繁的锁切换.... 没有跑不满的CPU 方圆，geek那是你程序的问题吧.不是语言的问题. 李振宇，运维/阿里巴巴from multiprocessing import Process.王所，抵制程序员鸡汤首先python单进程多线程情况下确实不能把多核CPU跑满,这个必须要承认,但是看了一些国内的答案(包括知乎),很多人认为python单进程不能利用多核,单进程只能跑在一个核,那么请问一下为什么单进程多线程python程序可以CPU占用达到100%以上需要注意的是python的线程是操作系统真实的线程,不是假的,所以是可以"同时"运行在多个核上,你可以看到cpu使用率超过了100%,虽然这个是监控系统取的平均值,虽然效率比串行还差劲......感觉说了白说,tmd,操蛋的GILguangyi，一念天堂python即使是单进程也可以用多线程把cpu跑满
备案号： 说三道四多核处理器的优点和缺点_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
多核处理器的优点和缺点
上传于||暂无简介
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩1页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢