Why do processes in Linux sleep?

Why do processes in Linux sleep?

In the Linux operating system, a process may become dormant due to a number of different reasons and conditions. When a process is in a dormant state, it means that the process is temporarily suspended and cannot continue execution until certain conditions are met before it can be awakened to continue execution. Next, we will introduce in detail several common situations when a process enters hibernation in Linux, and illustrate them with specific code examples.

1. Waiting for I/O to complete:
   When the process initiates an I/O operation (such as reading files, network communication, etc.), the process will be In the sleep state, execution cannot continue until the I/O operation is completed. Here is a simple example code that demonstrates a process waiting for reading a file to complete:

   #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); // Read file data and block the process until completion
       fclose(file);
   
       printf("File contents: %s
   ", buffer);
   
       return 0;
   }

2. Waiting for signals:
   The process may call functions such as sigwait() or sigwaitinfo() Waiting for the arrival of a signal, at which point the process will go to sleep until the specific signal arrives. Here is a simple example code that shows a process waiting to receive a 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); // Capture the SIGINT signal
   
       printf("Waiting for signal...
   ");
       sigset_t set;
       sigemptyset(&set);
       sigaddset(&set, SIGINT);
       int sig;
       sigwait(&set, &sig); // Wait for SIGINT signal
   
       printf("Signal received, exiting...
   ");
       return 0;
   }

3. Waiting for locks or resources:
   When a process accesses a shared resource, it may need to wait for permission to obtain a lock or access the resource. At this time, the process will Enter hibernation state. The following is a simple multi-threaded example code showing the process waiting to acquire the lock:

   #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); // Wait for lock
       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); // Wait for lock
       shared_data;
       printf("Main: shared_data = %d
   ", shared_data);
       pthread_mutex_unlock(&mutex);
   
       pthread_join(thread, NULL);
   
       return 0;
   }

To sum up, a process in Linux may enter a dormant state due to waiting for I/O to complete, waiting for a signal to arrive, or waiting for a lock or resource. Understanding the reasons and circumstances under which a process enters hibernation is crucial for system programming and debugging. Code examples can provide a more intuitive understanding of the hibernation state of a process and its impact.

The above is the detailed content of Why do processes in Linux sleep?. For more information, please follow other related articles on the PHP Chinese website!