How to accurately determine whether a process is running

1. Why do we need to determine whether the process exists?

Imagine this scenario: you write an automation script and need to check whether a background service has started. If you run your program directly and the dependent service is not started, the entire system may crash. At this time, using Python to automatically detect whether a process exists has become a key capability!

for example:

• Monitor whether MySQL on the server crashes unexpectedly
• Make sure the crawler does not start repeatedly
• Check whether the antivirus software is running normally

These requirements all require a reliable method to judge process status. Next we will use Python to implement this function!

2. Method 1: Use psutil library (recommended)

psutil is one of Python's strongest system monitoring libraries, and supports Windows/Linux/Mac across platforms. Install it:

pip install psutil

Code to check if Chrome is running:

import psutil

def is_process_running(process_name):
    for proc in psutil.process_iter(['name']):
        if ['name'] == process_name:
            return True
    return False

if is_process_running(''):
    print("Chrome is running!")
else:
    print("Chrome not running")

advantage:

• Concise code
• Supports fuzzy matching (such as just entering "chrome")
• Can obtain process details (CPU, memory, etc.)

Tested data:

Scan 1000 processes on the test machine in just 0.02 seconds!

3. Method 2: Use the calling system commands

Different operating systems need to use different commands:

Windows system:

import os

def check_process_win(process_name):
    return (f'tasklist | find "{process_name}"') == 0

print("Notepad is running" if check_process_win('') else "Not found")

Linux/Mac system:

def check_process_linux(process_name):
    return (f'pgrep -f "{process_name}"') == 0

shortcoming:

• Rely on system commands
• Different platforms need to write different codes
• Poor performance (new process is started every time)

4. Method 3: Use subprocess to obtain detailed process information

Want to process process information more flexibly? You can use the subprocess module:

import subprocess

def get_process_details(name):
    try:
        output = subprocess.check_output(['ps', '-aux']).decode()
        return [line for line in ('\n') if name in line]
    except:
        return []

chrome_processes = get_process_details('chrome')
print(f"turn up{len(chrome_processes)}indivualChromeprocess")

Applicable scenarios:

• Need to get the complete command line parameters of the process
• To analyze the resource usage of the process

5. Performance comparison test

We test 3 methods (detection) on the same machine:

Obviously, psutil is the comprehensive optimal solution! It is not only fast, but also obtains detailed information such as CPU, memory, etc. of the process. If you often need to do system monitoring, this library must be mastered.

6. Practical application cases

Case 1: Prevent scripts from running repeatedly

import psutil
import sys

current_pid = ()
for proc in psutil.process_iter(['pid', 'name']):
    if ['name'] == '' and ['pid'] != current_pid:
        print("There is already a Python process running!")
        ()

Case 2: Automatically restart the monitoring service

import time

while True:
    if not is_process_running(''):
        ('start nginx')  # Windows startup command        print("Nginx crash detected, restarted!")
    (60)  # Check once a minute

7. FAQ

Q: Why can't the process just started?

A: The process may take several milliseconds to register with the system. It is recommended to add a short delay during detection.

Q: How to match processes with parameters?

# Use psutil's cmdline property[() for p in psutil.process_iter() if 'python' in ()]

Q: What can be done after detecting a process?

• End process: ()
• Get resource occupation: process.cpu_percent()
• Analysis of child processes: ()

8. Complete code template

import psutil

class ProcessMonitor:
    @staticmethod
    def is_running(name):
        """Check if the process exists"""
        return name in (() for p in psutil.process_iter(['name']))
    
    @staticmethod
    def kill_process(name):
        """End the specified process"""
        for proc in psutil.process_iter(['name']):
            if ['name'] == name:
                ()
                return True
        return False

​​​​​​​#User Exampleif ProcessMonitor.is_running(''):
    print("Discover Notepad Process")
    ProcessMonitor.kill_process('')

9. Summary

It seems simple to judge whether the process exists, but in fact, you need to consider:

• Cross-platform compatibility: Windows and Linux commands are completely different
• Performance requirements: Efficient methods are required for frequent detection
• Extended requirements: Whether to obtain process details

Recommended choices:

• Use psutil (simple and reliable)
• Subprocess (flexible control) for special needs
• Temporary testing (fast verification)

This is the article about how Python accurately determines whether a process is running. For more related content on Python to determine whether a process is running, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!