Pourquoi les processus sous Linux dorment-ils ?

Pourquoi les processus sous Linux dorment-ils ?

Dans les systèmes d'exploitation Linux, les processus peuvent devenir inactifs pour un certain nombre de raisons et de conditions différentes. Lorsqu'un processus est dans un état dormant, cela signifie qu'il est temporairement suspendu et ne peut pas poursuivre son exécution tant que certaines conditions ne sont pas remplies avant de pouvoir être réveillé pour poursuivre son exécution. Ensuite, nous présenterons en détail plusieurs situations courantes lorsqu'un processus entre en veille prolongée sous Linux et les illustrerons avec des exemples de code spécifiques.

1. Attente de la fin des E/S :
   Lorsqu'un processus lance une opération d'E/S (telle que la lecture de fichiers, la communication réseau, etc.), le processus sera placé dans un état dormant et ne pourra pas continuer jusqu'à ce que l'opération d'E/S est terminée. Ce qui suit est un exemple de code simple qui montre le processus en attente de la fin de la lecture d'un fichier :

   #include <stdio.h>
   
   int main() {
       FILE *file = fopen("example.txt", "rb");
       if (file == NULL) {
           perror("Error opening file");
           return 1;
       }
   
       char buffer[256];
       fread(buffer, sizeof(char), 256, file); // 读取文件数据，阻塞进程直到完成
       fclose(file);
   
       printf("File contents: %s
   ", buffer);
   
       return 0;
   }

2. En attente de signaux :
   Le processus peut appeler sigwait()或sigwaitinfo() et d'autres fonctions pour attendre l'arrivée du signal, à à quel moment le processus entrera dans un état dormant jusqu'à ce qu'un signal spécifique arrive. Ce qui suit est un exemple de code simple qui montre le processus en attente de recevoir un signal :

   #include <stdio.h>
   #include <signal.h>
   #include <unistd.h>
   
   void signal_handler(int signum) {
       printf("Signal received: %d
   ", signum);
   }
   
   int main() {
       struct sigaction sa;
       sa.sa_handler = signal_handler;
       sigaction(SIGINT, &sa, NULL); // 捕获SIGINT信号
   
       printf("Waiting for signal...
   ");
       sigset_t set;
       sigemptyset(&set);
       sigaddset(&set, SIGINT);
       int sig;
       sigwait(&set, &sig); // 等待SIGINT信号
   
       printf("Signal received, exiting...
   ");
       return 0;
   }

3. En attente d'un verrou ou d'une ressource :
   Lorsqu'un processus accède à une ressource partagée, il peut devoir attendre un verrou ou une autorisation. pour accéder à la ressource. À ce moment-là, le processus se mettra en veille. Ce qui suit est un exemple de code multithread simple qui montre un processus en attente d'acquisition d'un verrou :

   #include <stdio.h>
   #include <pthread.h>
   
   pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
   int shared_data = 0;
   
   void *thread_function(void *arg) {
       pthread_mutex_lock(&mutex); // 等待获得锁
       shared_data++;
       printf("Thread: shared_data = %d
   ", shared_data);
       pthread_mutex_unlock(&mutex);
       return NULL;
   }
   
   int main() {
       pthread_t thread;
       pthread_create(&thread, NULL, thread_function, NULL);
   
       pthread_mutex_lock(&mutex); // 等待获得锁
       shared_data++;
       printf("Main: shared_data = %d
   ", shared_data);
       pthread_mutex_unlock(&mutex);
   
       pthread_join(thread, NULL);
   
       return 0;
   }

En résumé, un processus sous Linux peut attendre la fin des E/S, attendre l'arrivée d'un signal, ou en attente d'un verrou ou d'une ressource Entrez en état d'hibernation. Comprendre les raisons et les circonstances dans lesquelles un processus entre en veille prolongée est crucial pour la programmation et le débogage du système. Les exemples de code peuvent fournir une compréhension plus intuitive de l'état d'hibernation d'un processus et de son impact.

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!