Analyze why Linux processes enter sleep mode

To analyze why the Linux process enters sleep mode, specific code examples are needed

In the Linux system, the process will enter sleep for many reasons. model. Sleep mode includes waiting for resources, waiting for signals, and waiting for events. This article will analyze in detail why the Linux process enters sleep mode from these aspects, and explain it through specific code examples.

Waiting for resources

During execution, the process may need to access some shared resources, such as files, network connections, memory, etc. When a resource is occupied by another process or locked, the current process will enter sleep mode and wait for the resource to be released or unlocked.

The following is a sample code that shows a thread waiting to acquire a lock resource:

#include <stdio.h>
#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int shared_resource = 0;

void* thread_function(void* arg) {
    pthread_mutex_lock(&mutex);
    shared_resource;
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    
    pthread_mutex_lock(&mutex);
    while (shared_resource == 0) {
        pthread_mutex_unlock(&mutex);
        sched_yield(); // Actively give up the CPU to avoid busy waiting
        pthread_mutex_lock(&mutex);
    }
    pthread_mutex_unlock(&mutex);

    pthread_join(thread, NULL);
    
    return 0;
}

In the above code, the main thread waits for the sub-thread to obtain the lock resource before continuing execution. When the sub-thread obtains the lock resource, the main thread will exit the sleep state.

Waiting for signals

The process can communicate with the kernel and other processes through signals. When the process waits for the signal to arrive, it enters the sleep state. Signals can be processed through sigwait() or signal processing functions.

The following is a sample code that uses the sigwait() function to wait for a signal:

#include <stdio.h>
#include <signal.h>

int main() {
    sigset_t set;
    int sig_no;
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    sigprocmask(SIG_BLOCK, &set, NULL);
    sigwait(&set, &sig_no);
    printf("Received signal SIGUSR1
");
    return 0;
}

In the above code, the process blocks the SIGUSR1 signal. When the signal is received, it will exit the sleep state and perform the corresponding operations.

Waiting for events

The process sometimes needs to wait for certain events to occur, such as timer timeout, IO event readiness, etc. The process will go to sleep waiting for the event until the event occurs and wakes up the process.

The following is a sample code using IO multiplexing to wait for events:

#include <stdio.h>
#include <sys/select.h>

int main() {
    fd_set rfds;
    struct timeval tv;
    int retval;

    FD_ZERO(&rfds);
    FD_SET(0, &rfds);

    tv.tv_sec = 5;
    tv.tv_usec = 0;

    retval = select(1, &rfds, NULL, NULL, &tv);
    if (retval == -1) {
        perror("select()");
    } else if (retval) {
        printf("Data is available now.
");
    } else {
        printf("No data within five seconds.
");
    }

    return 0;
}

In the above code, the process uses the select() function to wait for data to be read from the standard input. When the data is readable or the wait times out, the process will be awakened.

To sum up, the Linux process will enter sleep mode due to waiting for resources, waiting for signals and waiting for events. The sleep behavior of a process can be better understood through concrete code examples.

The above is the detailed content of Analyze why Linux processes enter sleep mode. For more information, please follow other related articles on the PHP Chinese website!