Programmation serveur Python : comment les démons sont implémentés

Python est un langage de programmation très populaire, particulièrement largement utilisé dans la programmation réseau. La programmation côté serveur en fait également partie. Dans la programmation côté serveur, les processus démons sont un concept courant. Cet article explique comment implémenter des processus démons dans la programmation serveur Python.

Qu'est-ce qu'un processus démon

Dans le processus d'exécution du programme côté serveur, afin de garantir le fonctionnement stable à long terme du programme, nous devons le convertir en processus démon. Un démon est un processus qui s'exécute en continu en arrière-plan. Ce processus n'occupe pas la console ou la session de connexion et peut être automatiquement redémarré pour garantir que le programme s'exécute pendant une longue période.

Dans les systèmes Linux, les processus démons sont généralement implémentés via l'appel système fork(). Le processus d'implémentation spécifique est le suivant :

1. Appelez fork() pour créer un processus enfant.
2. Appelez setsid() dans le processus enfant pour créer une nouvelle session.
3. Appelez à nouveau fork() dans le processus enfant pour empêcher le processus enfant de devenir le processus principal de la session terminale.
4. Fermez tous les descripteurs de fichiers.
5. Redirigez l'entrée, la sortie et la sortie d'erreur standard vers /dev/null.

En Python, nous pouvons créer un processus démon en remplaçant la fonction run() du processus parent. L'implémentation spécifique est la suivante :

import os
import sys

class Daemon:
    def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
        self.stdin = stdin
        self.stdout = stdout
        self.stderr = stderr
        self.pidfile = pidfile

    def daemonize(self):
        if os.path.exists(self.pidfile):
            raise RuntimeError('PID file %s already exists' % self.pidfile)

        # First fork (detaches from parent)
        try:
            if os.fork() > 0:
                sys.exit(0)
        except OSError as e:
            raise RuntimeError('fork #1 failed: %d (%s)' % (e.errno, e.strerror))

        os.chdir('/')
        os.umask(0)
        os.setsid()

        # Second fork (relinquish session leadership)
        try:
            if os.fork() > 0:
                sys.exit(0)
        except OSError as e:
            raise RuntimeError('fork #2 failed: %d (%s)' % (e.errno, e.strerror))

        # Flush I/O buffers
        sys.stdout.flush()
        sys.stderr.flush()

        # Redirect standard file descriptors
        with open(self.stdin, 'rb', 0) as f:
            os.dup2(f.fileno(), sys.stdin.fileno())
        with open(self.stdout, 'ab', 0) as f:
            os.dup2(f.fileno(), sys.stdout.fileno())
        with open(self.stderr, 'ab', 0) as f:
            os.dup2(f.fileno(), sys.stderr.fileno())

        # Write pidfile
        with open(self.pidfile, 'w') as f:
            print(os.getpid(), file=f)

    def start(self):
        self.daemonize()
        self.run()

    def stop(self):
        if os.path.exists(self.pidfile):
            with open(self.pidfile) as f:
                os.kill(int(f.read()), signal.SIGTERM)
            os.remove(self.pidfile)

    def restart(self):
        self.stop()
        self.start()

    def run(self):
        raise NotImplementedError

Dans le code ci-dessus, nous créons un processus démon Python en implémentant une classe nommée Daemon. Parmi eux, la méthode self.daemonize() implémente le processus de création du processus démon, la méthode self.start() démarre le processus démon, la méthode self.stop() arrête le processus démon, la méthode self.restart() redémarre le processus démon et self. La méthode run() doit être réécrite en fonction de la situation réelle.

Lorsque vous utilisez Python pour implémenter un processus démon, vous devez faire attention aux problèmes suivants :

1. Les descripteurs de fichiers du processus parent et du processus enfant sont indépendants les uns des autres, et il peut y avoir un échec d'ouverture du processus déposer. Pour éviter que cela ne se produise, vous devez utiliser des chemins absolus pour les fichiers que vous souhaitez ouvrir.
2. Le flux de fichiers n'est pas accessible via sys.stdout et sys.stderr dans le processus démon. Par conséquent, ces flux de fichiers doivent être redirigés vers des fichiers pour faciliter la visualisation des journaux.
3. Assurez-vous de faire attention au traitement du signal dans le processus démon, car le processus démon s'exécute pendant une longue période et peut mourir en raison de fuites de mémoire et d'autres problèmes. Il doit être redémarré à temps lorsque des conditions anormales se produisent.
4. Les opérations liées au terminal ne peuvent pas être effectuées dans le processus démon, telles que l'obtention de la largeur et de la hauteur du terminal.

Résumé

Cet article présente comment implémenter des processus démons dans la programmation serveur Python. La création d'un démon Python est relativement simple, mais sa stabilité et sa gestion des erreurs nécessitent plus d'attention. Grâce à l'introduction de cet article, les lecteurs peuvent apprendre à utiliser Python pour créer un processus démon stable et fiable afin de garantir le fonctionnement stable à long terme des programmes côté serveur Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!