So Linux backend programming (2) : process · Whole family bucket

In Linux, processes can be created, terminated, and communicated between processes. The following is a brief introduction.

In order to enable concurrent execution of programs in multi-program environment, and to control and describe concurrent execution of programs, the concept of process is introduced. Program segment, data segment and process control block constitute the entity of a process.

1. Ready When a process has allocated all necessary resources except CPU and can execute as soon as it can acquire a processor, the state is called ready
2. Execution status means that the process has acquired the processor and its program is executing
3. Blocked State The state in which the execution of a process is suspended due to an event (such as an I/O request or a request for buffer space), that is, the execution of the process is blocked. Therefore, this state is called the blocked state, sometimes also called the “waiting” state or “sleep” state.

In process, CTRL+C.

End user Needs When an end user discovers a suspicious problem during the running of his or her program, he or she often wants to temporarily freeze his or her process. The needs of the parent process The parent process often wants to inspect and modify the child process or when coordinating the activities of the child process. The needs of the operating system The operating system sometimes needs to suspend certain processes to check the utilization of resources in the running and to do accounting in order to improve the performance of the system. In order to relieve the memory shortage, the process in the blocked state is transferred to the auxiliary memory, so that the process is in a new state that is different from the blocked state. The need for load regulationCopy the code

Process scheduling is the system according to a certain algorithm to dynamically allocate CPU to a ready process. Process scheduling is done through the process scheduler. The main functions of the process scheduler are: – Select the process to occupy the CPU – to switch the process context

This method stipulates that when a process is running, the system can strip the processor allocated to it based on certain principles, and allocate it to other process stripping principles: priority principle, short process priority principle, time slice principle

– Algorithm: selects the process with the shortest “next CPU execution period” from the ready queue, and allocates processors to it for execution – Advantage: can obtain better scheduling performance – Disadvantage: the CPU execution period of the process is difficult to accurately obtain, which is detrimental to long processes

– Algorithm: Allocates CPU to the process with the highest priority in the ready queue – The static priority is established when the process is created and remains unchanged during the run. The requirements are as follows: Process type, resource requirements, and user priority Advantages: Simple Disadvantages: The process cannot be dynamically displayed, and the system scheduling performance is poor

Algorithm: usually used in time-sharing systems, it schedules all the ready processes in the system in turn, so that the ready processes in turn get a time slice of the running time

• The principle of time slice length determination should not only ensure that each user process of the system can get the response in time, but also not increase the scheduling overhead and reduce the efficiency of the system because the time slice is too short

– The system sets multiple ready queues with different priorities. Each queue with a higher priority is scheduled first. The queue with a lower priority is scheduled only when the queue is empty. – Normally, newly created processes and processes that have not used up their time slices due to I/O requests are placed in the highest priority queue. In this queue, 2-3 processes that have not completed their time slices are placed in the next lower priority queue. – Whenever a process in the queue with a higher priority enters the queue, the system immediately switches to process scheduling and schedules processes in the queue with a higher priority in time. – Advantages: It can better meet the user requirements of all kinds of jobs. It can not only make the time-sharing user jobs get satisfactory response, but also make the batch user jobs get reasonable turnaround time

– The data structure on which process scheduling depends is usually scheduling queue. Due to different scheduling reasons, a variety of waiting queues are set up in the single-processor system. Only the process in the ready queue can obtain the processor and finally run. You must enter the ready queue to allocate processors – the setup structure of the queue data structure is closely related to the scheduling algorithm – the process scheduling algorithm simply decides which process will get the processor, and the assignment of the processor to that process is done by the dispatcher

#include <unistd.h>

pid_t fork(void);
Copy the code

Function: The child process copies the 0~3g space and PCB in the parent process, but the ID number is different.

Fork returns the child id of the parent process. The child id of the parent process is 0

Related functions:

#include<sys/types.h>
#include<unistd.h>

pid_t getpid(void); // Get the process ID
pid_t getppid(void); // Get the parent process ID
Copy the code

Fork is used to execute a new program. (After fork is created, both the child process and the parent process are scheduled by the OS at the same time. Therefore, the child process can execute a program independently, which will run concurrently with the parent process.)

Run new executable programs using exec family functions. Exec family functions can directly load and run a compiled executable program.

With the exec family of functions, a typical parent-child program looks like this: the program that the child needs to run is written separately, compiled separately and linked into an executable program (Hello). The main process is the parent process. Fork creates a child process and exec executes hello in the child process to achieve the effect of executing different programs simultaneously (macro).

#include<unistd.h>

int execve(const char *path,char *const argv[],char *const envp[]);// This is a real system call
// The following functions end up calling this function

int execl(const char *path,char *constArgv,...);
int execlp(const char *file,char *constArgv,...);
int execle(const char *path,char *constArgv,...char *const envp[]);
int execv(const char *path,char *const argv[]);
int execvp(const char *file,char *const argv,);
Copy the code

The exec family of functions loads and runs the program path/file, passing the arguments arg0(arg1, arg2, argv[], envp[]) to the subroutine, returning -1 on error.

Look at the suffixes:

Here are some easy-to-understand chestnuts that I found:

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

int main(int argc, char *argv[])
{
  // A pointer to a null-terminated array of strings, suitable for exec function arguments containing v
  char *arg[] = {"ls"."-a".NULL};
  
  /** * Create a child process and call the function execl * execl wants to receive a comma-separated list of arguments, terminated by a NULL pointer */
  if( fork() == 0 )
  {
    // in clild 
    printf( "1------------execl------------\n" );
    if( execl( "/bin/ls"."ls"."-a".NULL) = =- 1 )
    {
      perror( "execl error " );
      exit(1); }}/** * create a child process and call the function execv *execv wants to receive a pointer to a null-terminated array of strings */
  if( fork() == 0 )
  {
    // in child 
    printf("2------------execv------------\n");
    if( execv( "/bin/ls",arg) < 0)
    {
      perror("execv error ");
      exit(1); }}Execlp *l in execlp wants to receive a comma-separated list of arguments terminated by a NULL pointer *p is a null-terminated pointer to an array of strings. The function can find the subroutine file */ in the DOS PATH variable
  if( fork() == 0 )
  {
    // in clhild 
    printf("3------------execlp------------\n");
    if( execlp( "ls"."ls"."-a".NULL ) < 0 )
    {
      perror( "execlp error " );
      exit(1); }}*p is a null-terminated pointer to an array of strings. The function can find subroutine files in the DOS PATH variable */
  if( fork() == 0 )
  {
    printf("4------------execvp------------\n");
    if( execvp( "ls", arg ) < 0 )
    {
      perror( "execvp error " );
      exit( 1); }}The e function passes the specified parameter envp, allowing the child process to change its environment. Without the suffix E, the child process uses the current program's environment */
  if( fork() == 0 )
  {
    printf("5------------execle------------\n");
    if( execle("/bin/ls"."ls"."-a".NULL.NULL) = =- 1 )
    {
      perror("execle error ");
      exit(1); }}The e function execve * v expects to receive a pointer to a null-terminated array of strings. This function passes the specified parameter envp, allowing the child to change its environment. Without the suffix E, the child uses the current program's environment */
  if( fork() == 0 )
  {
    printf("6------------execve-----------\n");
    if( execve( "/bin/ls", arg, NULL) = =0)
    {
      perror("execve error ");
      exit(1); }}return EXIT_SUCCESS;
}
Copy the code

– Resource sharing – Cooperation

The processes that require only reading are called Reader processes, and other processes are called Writer processes. Multiple reader processes are allowed to read a shared object at The same time, but one writer process and other reader or writer processes are never allowed to access The shared object at The same time Problem is a synchronization Problem that only one Writer process must mutually access a shared object with other processes

① No more than four philosophers are allowed to eat at the same time to ensure that at least one philosopher can eat, and eventually the two chopsticks he used will be released so that more philosophers can eat. ② A philosopher is allowed to eat with chopsticks only when both his left and right chopsticks are available. ③ The philosopher with odd number should take the chopsticks on his left first and then the chopsticks on his right; Even-numbered philosophers do the opposite.

Insufficient resources shared by multiple processes cause deadlock as they compete for resources – competing for disposables and non-disposables – competing for non-disposables

When a process is running, resources are requested or released in an incorrect sequence, resulting in process deadlock. – Process advance sequence is valid. – Process advance sequence is invalid

In plain English, races.

• Deadlock prevention Prevents deadlocks by setting restrictions that break one or more of the four necessary conditions for a deadlock to occur.
• Deadlock Avoidance During the dynamic resource allocation process, a method is used to prevent the system from entering an insecure state, thus avoiding the occurrence of deadlock.
• Deadlock detection The deadlock detection method allows death locks to be issued during system operation. However, through the detection mechanism set up in the system, the occurrence of deadlock can be detected in time, and precisely determine the process and resources related to deadlock, and then take appropriate measures to eliminate the deadlock from the system
• Unlocking deadlock Unlocking is a facility that accompanies detecting deadlocks and is used to free a process from a deadlock state

The so-called safe state refers to the system can follow a certain process order such as (P1, P2,… , Pn) (called <P1, P2… , Pn> sequence is the safe sequence) to allocate the required resources to each process until the maximum demand, so that each process can successfully complete

If the system does not have such a security sequence, the system is said to be in an unsafe state

If resources are not allocated in a safe order, the system may change from a safe state to an unsafe state and deadlock may occur

Resource allocation graph is composed of a set of node N and a set of edge E. The node G =(N, E) is divided into two kinds of nodes: process node and resource node. Edges represent the request-allocation relationship between processes and resources

I wrote a lot until

Compared to the limitations of pipes, message queues are much more sensible because they hold “tail money” and therefore need to persist in the system.

Message queues are internal linked lists in the kernel address space that pass messages between different processes through the Linux kernel. Messages are sent sequentially to the message queue and retrieved from the queue in several different ways. 3. Message queues in the kernel are distinguished by IPC identifiers, and different message queues are independent of each other. 4. The messages in each message queue constitute an independent linked list.

I see it as a “nest of abundance”.

However, message queues do have their limitations: message queues are not suitable for large data transfers, because there is a maximum length limit for each message body in the kernel, as well as an upper limit on the total length of the entire message body contained in all queues. In the Linux kernel, there are two macros that define MSGMAX and MSGMNB, which define the maximum length of a message and the maximum length of a queue in bytes, respectively.

Message queue is very good, just look at the above features, than pipe space, slower than SHM, transmission message size is not as good as MMP, but also asynchronous, damn. It is such a “nothing” way of communication, forcibly turn their disadvantages into advantages, otherwise it does not know which box to be pressed to the bottom.

Yes, asynchronous.

With the emergence of “asynchronous service” (such as double eleven flow peak clipping, second kill system, etc.), message queue suddenly became hot property, it can carry more messages than pipes, it does not pursue speed, the memory is smaller than MMP, is simply used to do flow peak clipping, decoupling, asynchronous god.

RobbieMQ, RocketMQ, Kafka. Message queuing: decoupled, asynchronous, traffic peak shaving. What are the most popular TYPES of MQ and how to choose MQ for beginners?

Message queues are hot, and fate is amazing.

1. The mmap() function is used to map files or devices into memory. 2. Mmap is characterized by on-demand paging. At the beginning only apply vMA, do not adjust the real page. When a reference is made to a page, a missing page is interrupted and the page is brought back into memory, thus avoiding memory waste.

Mmap advantage: Manipulating files like memory is good for reading and writing large files.

The disadvantages of Mmap are as follows: 1. If the file is very small, such as 60bytes, since the organization in memory is page by page, the file is loaded into memory as a page 4K, so the other 4096-60=4036 bytes of memory space will be wasted.

First, distributed systems, which I think of when I see sockets for interprocess communication. Socket process communication can be across hosts, scalability, process distribution to different servers, change the port can be used. In contrast, no other IPC can cross machines.

Secondly, my brother told me every day that the server he learned could interact with cross-platform, Windows and Linux in the future. I asked him and he said that he had not learned yet, so what about now? Let me reveal the plot first.

On programming, TCP sockets and pipe are operating file descriptors, used for sending and receiving bytes, can read/write/an FCNTL/select/poll, etc, the difference is that TCP is full duplex, pipe is half duplex, not convenient.

Take the fastest IPC, SHM shared memory, that works? For technical not perfect friend, that can be really potholes, anyway I was black and blue. Some people may say, specific problem specific analysis, single use SHM, distributed use TCP, I would like to ask, interesting? Interesting? You love writing two pieces of code for the same feature. Compare SHM with TCP. TCP is a byte stream protocol that can only be read sequentially and has a write buffer. SHM is a messaging protocol where one process writes to a virtual address and another process reads away, basically blocking.

In fact, I like SHM communication very much, and even packaged dynamic libraries, which can be found under my “dynamic libraries” column, but, mutiny is so fast hahaha.

Again, what happens if IPC communication crashes? Period of error; TCP? The network is down. Which one is easy to find? At a glance. Once TCP breaks, reconnect where it broke. What about IPC? Then we have to start all over again.

It also works across languages ！！！！！

That’s it, click “like”, click “comment”, click “like”, click “like”, click “like”, click “like”, click “like”, click “like”, click “like”, click “like”