Five communication methods between processes required for interviews

Inter-Process Communication (IPC) refers to the transmission or exchange of information between different processes.

IPC methods usually include pipes (including unnamed pipes and named pipes), message queues, semaphores, shared storage, Sockets, Streams, etc. Among them, Sockets and Streams support IPC between two processes on different hosts.

[[283876]]

1. Pipeline

Pipes, usually unnamed pipes, are the oldest form of IPC in UNIX systems.

1. Features

• Half-duplex (data flows in only one direction), with fixed read and write ends
• Can only be used for communication between parent processes or brother threads (threads with blood relationship)
• A special file that can be read and written using ordinary read and write functions, but is not an ordinary file and does not belong to any other file system. It only exists in memory.

2. Prototype

 #include < unistd.h >  
 int pipe(int fd[2]); // Return value: 0 if successful, -1 if failed

When a pipe is created, it creates two file descriptors: fd[0] is opened for reading, and fd[1] is opened for writing. To close the pipe, just close these two file descriptors. As shown below:

3. Examples

A pipe in a single process is almost useless. Therefore, the process that calls pipe usually calls fork, which creates an IPC channel between the parent process and the child process. This is shown in the following figure:

Half-duplex pipe after fork

Pipeline from parent process to child process

If you want the data flow to flow from the parent process to the child process, close the parent process's read end (fd[0]) and the child process's write end (fd[1]); conversely, you can make the data flow from the child process to the parent process.

 #include < stdio.h >  
 #include < unistd.h >   
 
 int main()
 {
 int fd[2]; // two file descriptors
 pid_t pid;
 char buff[20]; 
 
 if(pipe(fd) <   0 ) // Create a pipeline
 printf("Create Pipe Error!\n"); 
 
 if(( pid = fork ()) <   0 ) // Create a child process
 printf("Fork Error!\n");
 else if(pid > 0) // parent process
 {
 close(fd[0]); // Close the read end
 write(fd[1], "hello world\n", 12);
 }
 else
 {
 close(fd[1]); // Close the write end
 read(fd[0], buff, 20);
 printf("%s", buff);
 } 
 
 return 0;
 }

2. Named Pipe (FIFO)

FIFO, also known as named pipe, is a type of file.

1. Features

• Unlike unnamed pipes, named pipes can communicate between unrelated processes.
• FIFO exists in the file system as a special device file with a path name associated with it.

2. Prototype

 #include < sys /stat.h >  
 int mkfifo(const char *pathname, mode_t mode); // Return value: 0 if successful, -1 if error occurs

The mode parameter is the same as the mode in the open function below.

3. Examples

Wirte:

 #include < stdio.h >  
 #include < stdlib.h > // exit
 #include < fcntl.h > // O_WRONLY
 #include < sys /stat.h >  
 #include < time.h > // time 
 
 int main()
 {
 int fd;
 int n, i;
 char buf[1024];
 time_t tp; 
 
 printf("I am %d process.\n", getpid()); // Indicates the process ID
 //When opening a FIFO, the difference between setting the non-blocking flag (O_NONBLOCK) and not setting it: 
 
 //If O_NONBLOCK is not specified (the default), a read-only open will block until some other process opens the FIFO for writing. Similarly, a write-only open will block until some other process opens it for reading. 
 
 If O_NONBLOCK is specified, a read-only open returns immediately, while a write-only open returns -1 on error. If no process has opened the FIFO for reading, its errno is set to ENXIO.
 if(( fd = open ("fifo1", O_WRONLY)) <   0 ) // Open a FIFO for writing
 {
 perror("Open FIFO Failed");
 exit(1);
 } 
 
 for( i = 0 ; i < 10 ; ++i)
 {
 time(&tp); // Get the current system time
 n = sprintf (buf,"Process %d's time is %s",getpid(),ctime(&tp));
 printf("Send message: %s", buf); // Print
 if(write(fd, buf, n+1) <   0 ) // Write to FIFO
 {
 perror("Write FIFO Failed");
 close(fd);
 exit(1);
 }
 sleep(1); // sleep for 1 second
 } 
 
 close(fd); // Close the FIFO file
 return 0;
 }

read:

 #include < stdio.h >  
 #include < stdlib.h >  
 #include < errno.h >  
 #include < fcntl.h >  
 #include < sys /stat.h >   
 
 int main()
 {
 int fd;
 int len;
 char buf[1024]; 
 
 if(mkfifo("fifo1", 0666) <   0 && errno!=EEXIST) // Create FIFO pipe
 perror("Create FIFO Failed"); 
 
 if(( fd = open ("fifo1", O_RDONLY)) <   0 ) // Open FIFO for reading
 {
 perror("Open FIFO Failed");
 exit(1);
 } 
  
 while(( len = read (fd, buf, 1024)) > 0) // Read FIFO pipe
 printf("Read message: %s", buf); 
 
 close(fd); // Close the FIFO file
 return 0;
 }

3. Message Queues

A message queue is a linked list of messages stored in the kernel. A message queue is identified by an identifier (i.e., queue ID).

1. Features

• Message queues are record-oriented, where messages have a specific format and a specific priority.
• The message queue is independent of the sending and receiving processes. When the process terminates, the message queue and its contents are not deleted.
• The message queue can realize random query of messages. Messages do not have to be read in the order of first-in-first-out, but can also be read by message type.

2. Prototype

 #include < sys /msg.h >  
 // Create or open a message queue: Returns the queue ID if successful, -1 if failed
 int msgget(key_t key, int flag);
 // Add message: return 0 if successful, -1 if failed
 int msgsnd(int msqid, const void *ptr, size_t size, int flag);
 // Read message: Return the length of the message data if successful, or -1 if failed
 int msgrcv(int msqid, void *ptr, size_t size, long type, int flag);
 // Control the message queue: return 0 if successful, -1 if failed
 int msgctl(int msqid, int cmd, struct msqid_ds *buf);

In the following two cases, msgget will create a new message queue:

• If there is no message queue corresponding to the key value key, and flag contains the IPC_CREAT flag.
• The key parameter is IPC_PRIVATE.

When the msgrcv function reads a message queue, the type parameter has the following conditions:

• type == 0, returns the first message in the queue;
• type > 0, returns the first message of type type in the queue;
• type < 0, returns the message in the queue whose type value is less than or equal to the absolute value of type. If there are multiple messages, take the message with the smallest type value.

As can be seen, when the type value is not 0, it is used to read messages in a non-FIFO order. You can also think of type as a priority weight.

3. Examples

msg_server:

 #include < stdio.h >  
 #include < stdlib.h >  
 #include < sys /msg.h >   
 
 // Used to create a unique key
 #define MSG_FILE "/etc/passwd" 
 
 // Message structure
 struct msg_form {
 long mtype;
 char mtext[256];
 }; 
 
 int main()
 {
 int msqid;
 key_t key;
 struct msg_form msg; 
  
 // Get the key value
 if(( key = ftok (MSG_FILE,'z')) <   0 )
 {
 perror("ftok error");
 exit(1);
 } 
 
 // Print key value
 printf("Message Queue - Server key is: %d.\n", key); 
 
 // Create a message queue
 if (( msqid = msgget (key, IPC_CREAT|0777)) == -1)
 {
 perror("msgget error");
 exit(1);
 } 
 
 // Print message queue ID and process ID
 printf("My msqid is: %d.\n", msqid);
 printf("My pid is: %d.\n", getpid()); 
 
 // Loop to read messages
 for(;;)
 {
 msgrcv(msqid, &msg, 256, 888, 0); // Return the first message of type 888
 printf("Server: receive msg.mtext is: %s.\n", msg.mtext);
 printf("Server: receive msg.mtype is: %d.\n", msg.mtype); 
 
 msg.mtype = 999 ; // Message type received by the client
 sprintf(msg.mtext, "hello, I'm server %d", getpid());
 msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
 }
 return 0;
 }

msg_client:

 #include < stdio.h >  
 #include < stdlib.h >  
 #include < sys /msg.h >   
 
 // Used to create a unique key
 #define MSG_FILE "/etc/passwd" 
 
 // Message structure
 struct msg_form {
 long mtype;
 char mtext[256];
 }; 
 
 int main()
 {
 int msqid;
 key_t key;
 struct msg_form msg; 
 
 // Get the key value
 if (( key = ftok (MSG_FILE, 'z')) <   0 )
 {
 perror("ftok error");
 exit(1);
 } 
 
 // Print key value
 printf("Message Queue - Client key is: %d.\n", key); 
 
 // Open the message queue
 if (( msqid = msgget (key, IPC_CREAT|0777)) == -1)
 {
 perror("msgget error");
 exit(1);
 } 
 
 // Print message queue ID and process ID
 printf("My msqid is: %d.\n", msqid);
 printf("My pid is: %d.\n", getpid()); 
 
 // Add a message of type 888
 msg.mtype = 888 ;
 sprintf(msg.mtext, "hello, I'm client %d", getpid());
 msgsnd(msqid, &msg, sizeof(msg.mtext), 0); 
 
 // Read messages of type 777
 msgrcv(msqid, &msg, 256, 999, 0);
 printf("Client: receive msg.mtext is: %s.\n", msg.mtext);
 printf("Client: receive msg.mtype is: %d.\n", msg.mtype);
 return 0;
 }

4. Semaphore

Semaphore is different from the IPC structure already introduced. It is a counter. Semaphore is used to achieve mutual exclusion and synchronization between processes, rather than to store inter-process communication data.

1. Features

• Semaphores are used for synchronization between processes. If you want to transfer data between processes, you need to combine shared memory
• Semaphores are based on the PV operation of the operating system, and the program's operations on semaphores are all atomic operations.
• Each PV operation on the semaphore is not limited to adding or subtracting 1 from the semaphore value, but can also add or subtract any positive integer.
• Support semaphore groups

2. Prototype

The simplest semaphore is a variable that can only take values ​​of 0 and 1. This is also the most common form of semaphore, called a binary semaphore. A semaphore that can take multiple positive integers is called a universal semaphore.

The semaphore functions under Linux all operate on a general semaphore array rather than on a single binary semaphore.

 #include < sys /sem.h >  
 // Create or get a semaphore group: if successful, returns the semaphore set ID, if failed, returns -1
 int semget(key_t key, int num_sems, int sem_flags);
 // Operate on the semaphore group to change the value of the semaphore: return 0 if successful, -1 if failed
 int semop(int semid, struct sembuf semoparray[], size_t numops);
 // Control semaphore information
 int semctl(int semid, int sem_num, int cmd, ...);

When semget creates a new semaphore set, the number of semaphores in the set (num_sems) must be specified, usually 1; if an existing set is referenced, num_sems is specified as 0.

In the semop function, the sembuf structure is defined as follows:

 struct sembuf
 {
 short sem_num; // The corresponding sequence number in the semaphore group, 0 to sem_nums-1
 short sem_op; // The amount of change in the semaphore value in one operation
 short sem_flg; // IPC_NOWAIT, SEM_UNDO
 }

5. Shared Memory

1. Features

• Shared memory is the fastest type of IPC because the process directly accesses the memory
• Because multiple processes can operate simultaneously, synchronization is required
• Semaphores + shared memory are often used together, semaphores are used to synchronize access to shared memory

2. Prototype

 #include < sys /shm.h >  
 // Create or get a shared memory: return the shared memory ID if successful, or -1 if failed
 int shmget(key_t key, size_t size, int flag);
 // Connect shared memory to the address space of the current process: return a pointer to the shared memory if successful, or -1 if failed
 void *shmat(int shm_id, const void *addr, int flag);
 // Disconnect from shared memory: return 0 if successful, -1 if failed
 int shmdt(void *addr);
 // Control the related information of shared memory: return 0 if successful, return -1 if failed
 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

When creating a shared memory segment using the shmget function, its size must be specified; if an existing shared memory segment is referenced, the size must be specified as 0.

Once a shared memory is created, it cannot be accessed by any process. You must use the shmat function to connect the shared memory to the address space of the current process. After the connection is successful, the shared memory area object is mapped to the address space of the calling process, and then it can be accessed like a local space.

The shmdt function is used to disconnect the connection established by shmat. Note that this does not delete the shared memory from the system, but only makes the current process no longer able to access the shared memory.

The shmctl function can perform various operations on shared memory, and performs corresponding operations according to the parameter cmd. The commonly used one is IPC_RMID (delete the shared memory from the system).