Le processus démon est un processus spécial dans le système Linux. Il s'exécute en arrière-plan sans terminal de contrôle et n'est pas soumis à l'interférence de l'utilisateur. Il est responsable de l'exécution de certaines tâches et fonctions liées au système ou aux applications. Le rôle du démon est d'améliorer la stabilité et l'efficacité du système pour faire face à certains accidents ou anomalies inattendus. Dans les appareils Linux embarqués, les processus démons peuvent être utilisés pour protéger le processus principal du système et l'empêcher de se terminer anormalement, provoquant un crash complet du système et endommageant l'expérience utilisateur. Mais comprenez-vous vraiment le processus démon sous Linux ? Savez-vous comment écrire et utiliser un démon simple sous Linux ? Cet article vous présentera en détail les connaissances pertinentes sur les processus démons sous Linux, vous permettant de mieux utiliser et comprendre ce puissant type de processus sous Linux.
Créez un processus démon dans un appareil Linux pour protéger le processus principal du système et éviter que certains accidents inattendus ne provoquent une fin anormale du processus principal, provoquant l'arrêt complet du système sans aucune réponse, détruisant l'expérience utilisateur. Cependant, après avoir examiné de nombreuses informations, j'ai constaté que la plupart des gens parlaient uniquement de la façon de créer et d'implémenter des processus démons sur la plate-forme x86, et que personne n'expliquait comment créer et implémenter des processus démons sur les plates-formes embarquées. Ainsi, après quelques explorations et une compréhension générale de tout, des principes au code, j'ai moi-même trouvé quelques idées. Vous trouverez ci-dessous un bref résumé et une organisation.
Ce qui suit est un extrait d'Internet sur l'introduction et la description du processus démon dans le système Linux x86.
Le démon est un processus spécial qui s'exécute en arrière-plan. Il est indépendant du terminal de contrôle et exécute périodiquement certaines tâches ou attend le traitement de certains événements.
Le processus démon est un processus orphelin spécial. Ce type de processus quitte le terminal. Pourquoi doit-il quitter le terminal ? La raison pour laquelle il est séparé du terminal est d'éviter que le processus ne soit interrompu par des informations générées par n'importe quel terminal, et ses informations pendant l'exécution ne seront affichées sur aucun terminal. Puisque sous Linux, l'interface par laquelle chaque système communique avec les utilisateurs est appelée un terminal, chaque processus qui démarre à partir de ce terminal sera attaché à ce terminal. Ce terminal est appelé le terminal de contrôle de ces processus lorsque le terminal de contrôle est fermé. , Les processus correspondants seront automatiquement fermés. Cependant, le processus démon peut dépasser cette limitation. Il est séparé du terminal et s'exécute en arrière-plan. Le but d'être séparé du terminal est d'empêcher que les informations pendant le processus en cours d'exécution ne soient affichées dans n'importe quel terminal et que le processus le fasse. ne sera accessible par aucun terminal. Interrompu par le message de terminal généré. Il commence à s'exécuter lorsqu'il est exécuté et ne se termine que lorsque tout le système est arrêté (cela peut bien sûr être considéré comme tuant le processus démon correspondant). Si vous souhaitez qu'un processus ne soit pas affecté par l'utilisateur, une interruption ou d'autres modifications, vous devez alors transformer ce processus en processus démon.
Pour les systèmes Linux sur la plate-forme x86, théoriquement, afin d'obtenir les effets ci-dessus, le processus démon comporte un ensemble strict d'étapes de mise en œuvre. En d’autres termes, le processus démon doit supprimer certaines restrictions liées au système au début du démarrage, afin qu’il puisse s’exécuter de manière stable en arrière-plan sans être interféré ni affecté par d’autres tâches.
Voici le processus de base d'écriture d'un démon sur la plateforme x86 :
–
Ce qui suit est un ensemble complet de codes sources tirés du blog d'un senior :
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
int init_daemon(void) {
int pid; int i; // 1）屏蔽一些控制终端操作的信
号 signal(SIGTTOU,SIG_IGN); signal(SIGTTIN,SIG_IGN); signal(SIGTSTP,SIG_IGN); signal(SIGHU
P ,SIG_IGN); // 2）在后台运行 if( pid=fork() ){// 父进程 exit(0);//结束父进程，子进程继
续 }else if(pid 的宏定义 // NOFILE 为文件描述符最大个数，不同系统有不同限
制 for(i=0; i
Il ressort de la logique de processus ci-dessus et du code réel que le processus démon de la plate-forme x86 est en fait assez complexe et nécessite un certain nombre de processus d'initialisation fastidieux. Cependant, pour les plateformes embarquées, le processus semble plus simple, sans traitement aussi compliqué. Parce que le processus démon est activé dans ce système embarqué. Le but est simplement d'utiliser ce processus démon pour démarrer un autre processus démonisé, puis de surveiller régulièrement si le processus fonctionne toujours normalement. Une fois qu'il s'avère qu'il fonctionne anormalement, redémarrez simplement le processus immédiatement.
J'ai donc simplifié le processus ci-dessus et j'ai obtenu le processus suivant :
Ce qui suit est le code complet du module de processus démon conçu dans ce projet de système embarqué.
/******************************************************************************************
******** ** 函数名称: lockfile ** 功能描述: 对文件加锁/解锁 ** 输入参数: lock: 1表示进行加锁处理，
0表示进行解锁处理 ** 输出参数: 无 ** 返回参
数: 无 *************************************************************************************
*************/ int tryto_lockfile(int fd, int lock) { struct flock fl; fl.l_type = (lock =
= 1) ? F_WRLCK : F_UNLCK; fl.l_start = 0; fl.l_whence = SEEK_SET; fl.l_len = 0; return (f
cntl(fd, F_SETLK, &fl)); } /***************************************************************
*********************************** ** 函数名称: get_proc_running_state ** 功能描述: 获取进程
运行状态 ** 输入参数: 无 ** 输出参数: 无 ** 返回参数: 返回-1表示路径错误 ** 返回参数: 返回0表示进程
从未运行过，返回1表示进程曾经运行过但是现在停止运行了，返回2表示进程正在运行
中 ****************************************************************************************
**********/ static int get_proc_running_state(const char* filename) { int fd; if (filename
== NULL) { /* 文件名为
空 */ return -1; } fd = open(filename, O_RDWR, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); i
f (fd 0) { /* 文件不存在，表示进程从未运行
过 */ return 0; } if (tryto_lockfile(fd, 1) == -1) { /* 文件加锁失败，表示进程在运行
中 */ close(fd); return 2; } else { /* 文件加锁成功，表示进程已经消
失 */ tryto_lockfile(fd, 0); /* 此处要注意记得解锁和关闭文
件 */ close(fd); return 1; } } /***********************************************************
*************************************** ** 函数名称: proc_watch ** 功能描述: 检测进程是否有在运
行，没有运行则重新启动之 ** 输入参数: procname: 进程名 ** 输出参数: 无 ** 返回参数: 返回-1表示进程从
未运行过；返回0表示进程当前运行正常； ** 返回参数: 返回其他非零值表示进程不存在且已被重新启动，返回的值
是新的pid值 ***************************************************************************
***********************/ int proc_watch(const char *procname) { int result, state; char fi
lename[100]; result = 0; sprintf(filename, "/var/run/%s.pid", procname); state = get_proc_
running_state(filename); switch (state) { case 0: result = -1; break; case 1: result = sta
rt_proc_by_name(procname); break; case 2: result = 0; break; default: break; } return resu
lt; } /************************************************************************************
************** ** 函数名称: start_proc ** 功能描述: 启动进程开始运行 ** 输入参数: 无 ** 输出参
数: 无 ** 返回参数: 进程的ID号，若启动失败则返回
0 *****************************************************************************************
*********/ int start_proc_by_name(const char* procname) { pid_t pid, child_pid; char filen
ame[100]; sprintf(filename, "%s%s", PROC_FILE_PATH, procname); child_pid = 0; if (access(f
ilename, X_OK | F_OK) != 0) { /* 如果文件存在，并且可执行 */ return 0; } pid = fork(); /* 首
先要fork一个进程出来 */ if (pid 0) { /* 创建进程失
败 */ return 0; } else if (pid == 0) { /* 创建进程成功，此处是子进程的代
码 */ if (execl(filename, procname, (char *)NULL) != -1) { return 1; } else { return 0; }
} else { /* 创建进程成功，此处是父进程代
******************************************************************* ** 函数名
称: thread_client_hdl ** 功能描述: client进程监视线程 ** 输入参数: 无 ** 输出参数: 无 ** 返回参
数: 无 *************************************************************************************
*************/ static void *thread_client_hdl(void *pdata) { int result; pdata = pdata; sl
eep(10); /* 第一次要进行延
时 */ for (;;) { printf("time to check thread_client...\n"); result = proc_watch(PROC_NAME
_CLIENT); if (result == -1) { printf("thread_client never exist...\n"); } else if (result
== 0) { printf("thread_client running ok...\n"); } else { printf("thread_client has gone!
but restarted...\n"); } sleep(10); } return NULL; } /*************************************
************************************************************* ** 函数名称: main ** 功能描
述: 入口主函数 ** 输入参数: 无 ** 输出参数: 无 ** 返回参
数: 无 *************************************************************************************
*************/ int main(int argc, char *argv[]) { int client_para; char *p, *process_name;
pthread_t thread_client; process_name = argv[0]; /* 获取进程名
称 */ p = process_name + strlen(process_name); while (*p != '/' && p != process_name) { p-
-; } if (*p == '/') { process_name = p + 1; } printf("\"%s\" starting...\n", process_name)
; client_para = 0x01; if (pthread_create(&thread_client, NULL, thread_client_hdl, &client_
para) != 0) { printf("create thread_client failed!\n"); return 1; } if (start_proc_by_name
(PROC_NAME_CLIENT) == 0) { printf("start thread_client failed!\n"); return 1; } for (;;) {
sleep(60); printf("i am still alive...\n"); } return 0; }
通过本文，你应该对 Linux 下的守护进程有了一个基本的了解，知道了它的定义、特点和用途。你也应该明白了如何在 Linux 下编写和使用简单的守护进程，以及使用守护进程时需要注意的一些问题和技巧。我们建议你在使用 Linux 系统时，使用守护进程来提高系统的稳定性和效率。同时，我们也提醒你在使用守护进程时要注意一些潜在的问题和挑战，如信号处理、日志记录、资源管理等。希望本文能够帮助你更好地使用 Linux 系统，让你在 Linux 下掌握守护进程的编写和使用。
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
