在现代的计算机系统中，服务器进程是处理来自客户端请求的程序。在一些场景中，特别是在需要协调多个进程或服务器的情况下，进程的可见性和控制变得非常重要。Python是一种流行的编程语言，提供了一些有效的方法来获取指定的服务器进程。本文将介绍在Python中获取不同类型的服务器进程的方法。
1. 获取正在运行的进程
在Python中，可以使用psutil模块获取当前运行的进程信息。psutil是一个跨平台的Python库，提供了丰富的系统进程和系统状态信息。我们可以使用psutil库来获取指定服务器进程。
需要使用pip安装psutil模块：
“`
pip install psutil
“`
接下来，我们可以通过以下代码获取正在运行的进程：
“`
import psutil
process = ‘mysql’ # 指定进程的名称
pid = None
# 获取所有运行中的进程
for proc in psutil.process_iter([‘pid’, ‘name’]):
process_name = proc.info[‘name’]
if process_name == process:
pid = proc.info[‘pid’]
break
if pid:
print(f”{process} is running with pid {pid}”)
else:
print(f”{process} is not running”)
“`
本例中，我们指定了要获取的进程名称为“mysql”。代码遍历所有正在运行中的进程，并将匹配的进程信息存储在变量pid中，最后打印出进程id以及进程状态。
2. 获取远程服务器的进程
在获取远程服务器上的进程之前，我们需要建立一个连接以允许远程访问。对于SSH连接，可以使用paramiko库。paramiko是一个Python SSH客户端库，提供了简单的SSH创建和连接方法。
需要安装paramiko库：
“`
pip install paramiko
“`
接下来，可以使用以下代码来建立SSH连接：
“`
import paramiko
remote_host = “example.com”
username = “root”
password = “your_password”
# 建立SSH连接
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname=remote_host, username=username, password=password)
# 执行远程命令
stdin, stdout, stderr = ssh.exec_command(“ps -ef | grep mysql | grep -v grep”)
output = stdout.read()
if len(output) > 0:
print(“MySQL is running”)
else:
print(“MySQL is not running”)
“`
在上面的例子中，我们使用SSH连接到远程主机，并执行了一个简单的命令来检查MySQL进程是否在运行。我们检查输出以检测进程是否在运行。
3. 使用pywin32获取Windows进程
如果要获取Windows操作系统中的进程信息，可以使用pywin32模块。pywin32是用于在Windows平台上使用Python的扩展模块库。
需要安装pywin32模块：
“`
pip install pywin32
“`
接下来，我们可以使用以下代码获取正在运行的进程：
“`
import win32com.client
process_name = “chrome.exe”
# 创建WMI连接
wmi = win32com.client.GetObject(‘winmgmts:’)
# 查询进程
process = wmi.ExecQuery(f”SELECT * FROM Win32_Process WHERE Name = ‘{process_name}’”)
if len(process) > 0:
print(f”{process_name} is running”)
else:
print(f”{process_name} is not running”)
“`
在上面的例子中，我们使用WMI连接查询正在运行的进程，其中进程名称为“chrome.exe”。我们检查查询结果以检测进程是否在运行。
本文介绍了在Python中获取服务器进程的三种方法。psutil模块可用于获取正在运行的进程，paramiko库可用于获取远程服务器上的进程，而pywin32模块可用于获取Windows操作系统中的进程。这些方法提供了不同的选项，可以帮助我们有效地获取系统进程信息。
相关问题拓展阅读：
- python怎么实现一个进程
- python技巧-使用 faulthandler 模块获取运行中进程的 traceback 信息
python怎么实现一个进程
想要充分利用多核CPU资源，Python中大部分情况下都需要使用多进程，Python中提供了multiprocessing这个包实现多进程。multiprocessing支持子进程、进程间的同步与通信，提供了Process、Queue、Pipe、Lock等组件。
开辟子进程
multiprocessing中提供了Process类来生成进程实例
Process(>>>>)1
group分组，实际上不使用
target表示调用对象，你可以传入方法的名字
args表示给调用对象以元组的形式提供参数，比如target是函数a，他有两个参数m，n，那么该参数为args=(m, n)即可
kwargs表示调用对象的字典
name是别名，相当于给这个进程取一个名字
先来个小例子：
# -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
n = 0
while n
time.sleep(wTime) #等待（休眠）
n += 1if __name__ == “__main__”:
p = Process(target=run_proc, args=(2,)) #申请子进程
p.start() #运行进程
print “Parent process run. subProcess is “, p.pid print “Parent process end,{0}”.format(time.ctime())9
运行结果：
Parent process run. subProcess is
Parent process end,Mon Mar 27 11:20:
subProcessrun, Mon Mar 27 11:20:
subProcessrun, Mon Mar 27 11:20:
subProcessrun, Mon Mar 27 11:20:
根据运行结果可知，父进程运行结束后子进程仍然还在运行，这可能造成僵尸（ zombie）进程。
通常情况下，当子进程终结时，它会通知父进程，清空自己所占据的内存，并在内核里留下自己的退出信息。父进程在得知子进程终结时，会从内核中取出子进程的退出信息。但是，如辩衡果父进程早于子进程终结，这可能造成子进程的退出信息滞留在内核中，子进程成为僵尸（zombie）进程。当大量僵尸进程积累时，内存空间会被挤占。
有什么办法可以避免僵尸进程呢？
这里介绍进程的一个属性 deamon，当其值为TRUE时，其父进程结束，该进程也直接终止运行（即使还没运行完）。
所以给上面的程序加上p.deamon = true，看看效果。
# -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
n = 0
while n
time.sleep(wTime)
n += 1if __name__ == “__main__”:
p = Process(target=run_proc, args=(2,))
p.daemon = True #加胡仿入daemon
p.start() print “Parent process run. subProcess is “, p.pid print “Parent process end,{0}”.format(time.ctime())920
执行结果：
Parent process run. subProcess is
Parent process end,Mon Mar 27 11:40:
这是问题又来了，子进程并没有执行完，这不是所期望的结果。有没办法将子进程执行完后才让父进程结束呢？
这里引入p.join()方法，它使子进程执行结束后，父进程才执行之后的代码
# -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
n = 0
while n
time.sleep(wTime)
n += 1if __name__ == “__main__”:
p = Process(target=run_proc, args=(2,))
p.daemon = True
p.start()
p.join() #加入join方法
print “Parent process run. subProcess is “, p.pid print “Parent process end,{0}”.format(time.ctime())92023
执行结果：
subProcessrun, Mon Mar 27 11:46:
subProcessrun, Mon Mar 27 11:46:
subProcessrun, Mon Mar 27 11:46:
Parent process run. subProcess is
Parent process end,Mon Mar 27 11:46:
这样所有的进程就能顺利的执行了。
将进程定义成类
通过继承Process类，来自定义进程类，实现run方法。实例p通过调用p.start()时自动调用run方法。
如下：
# -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timeclass Myprocess(Process):
def __init__(self, wTime):
Process.__init__(self)
self.wTime = wTime def run(self):
n = 0
while n
time.sleep(self.wTime)
n += 1if __name__ == “__main__”:
p = Myprocess(2)
p.daemon = True
p.start() #自动调用run方法
p.join() print “Parent process run. subProcess is “, p.pid print “Parent process end,{0}”.format(time.ctime())62728
执行结果和上一个例子相同。
创建多个进程
很多时候系统都需要创建多个进程以提高CPU的利用率，当数量较少时，可以手动生成一个个Process实例。当进程数量很多时，或许可以利用循环，但是这需要程序员手动管理系统中并发进程的数量，有时会很麻烦。这时进程池Pool就可以发挥其功效了。可以通过传递参数限制并发进程的数量，默认值为CPU的核数。
直接上例子：
# -*- coding:utf-8 -*-from multiprocessing import Process,Poolimport os,timedef run_proc(name):##定义一个函数用于进程调用
for i in range(5):
time.sleep(0.2) #休眠0.2秒
print ‘Run child process %s (%s)’ % (name, os.getpid())#执行一次该函数共需1秒的时间if __name__ ==’__main__’: #执行主进程
print ‘Run the main process (%s).’ % (os.getpid())
mainStart = time.time() #记录主进程开始的时间
p = Pool(8)#开辟进程池
for i in range(16): #开辟14个进程
p.apply_async(run_proc,args=(‘Process’+str(i),))#每个进程都调用run_proc函数，
#args表示给该函数传递的参数。
print ‘Waiting for all subprocesses done …’
p.close() #关闭进程池
p.join() #等待开辟的所有进程执行完后，主进程才继续往下执行
print ‘All subprocesses done’
mainEnd = time.time() #记录主进程结束时间
print ‘All process ran %0.2f seconds.’ % (mainEnd-mainStart) #主进程执行时间
执行结果：
开头部分
Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)
末尾部分：
Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.
相关说明：
这里进程池对并发进程的限制数量为8个，而程序运行时会产生16个进程，进程池将自动管理系统内进程的并发数量，其余进程将会在队列中等待。限制并发数量是因为，系统中并发的进程不是越多越好，并发进程太多，可能使CPU大部分的时间用于进程调度，而不是执行有效的计算。
采用多进程并发技术时，就单个处理机而言，其对进程的执行是串行的。但具体某个时刻哪个进程获得CPU资源而执行是不可预知的（如执行结果的开头部分，各进程的执行顺序不定），这就体现了进程的异步性。
python技巧-使用 faulthandler 模块获取运行中进程的 traceback 信息
Python 3.3 新增了一个 faulthandler 模块，可以输出运行中进程的告备 traceback 信息，可以用来作为调试运行中的 Python 进程的一种手段。
模块本身是使袜亏毁用 C 实现的，空昌所以有如下特点和限制：
Python 3.3 自带了这个模块，Python 2.x 可以通过一下方式安装:
测试函数:
使用 faulthandler 输出所有线程的 traceback 信息:
关于python获取服务器指定进程的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
