Maison  >  Article  >  Opération et maintenance  >  Linux peut-il créer plusieurs processus ?

Linux peut-il créer plusieurs processus ?

王林
王林avant
2023-05-20 18:32:461482parcourir

Linux peut créer plusieurs processus. Linux peut gérer plusieurs tâches en même temps et prendre en charge plusieurs processus pour maximiser l'utilisation des ressources système. Méthodes de communication entre les processus Linux : 1. Utiliser des canaux sans nom ; 2. Utiliser des canaux nommés (FIFO) ; 3. Utiliser des signaux uniques ; 5. Utiliser des files d'attente de messages ;

Linux peut créer plusieurs processus.

linux prend en charge plusieurs processus. L'un des avantages d'un système multi-processus est qu'il peut gérer plusieurs tâches en même temps pour obtenir une utilisation maximale des ressources système.

Chapitre 1 Introduction aux multi-processus Linux

1.1 Présentation

1.1.1 Concept de processus

Sous Linux, le programme en cours d'exécution est appelé un processus.
Programme : Concept statique, il s'agit d'un fichier binaire compilé
Process : Concept dynamique, lorsque le programme est en cours d'exécution, le système exécutera automatiquement un processus correspondant
Le processus contient le Process Control Block (PCB), code segment, segment de donnéesTrois parties
Bloc de contrôle de processus : Il est représenté par une structure sous Linux, enregistrant les informations d'état du processus
Processus zombie : Le processus parent se termine avant le processus enfant
Si vous créez un processus enfant, mais les ressources du processus enfant ne sont pas recyclées dans le processus parent, alors le processus enfant deviendra un processus zombie, et le processus zombie sera éventuellement recyclé par un processus appelé INIT dans le système.
Le processus init (processus n°1) est le premier processus qui s'exécute au démarrage du système et est le processus ancêtre de tous les processus. 1.1.2 Commande shell d'affichage des processus

bg
    Mettez le processus suspendu à s'exécuter en arrière-plan
  • 1.2 Statut d'exécution du processus
  • 1.2.1 Statut d'exécution

  • Statut d'exécution (RUNNING) : Le processus occupe le CPU.
  • État Prêt (EXÉCUTION) : Le processus est dans la file d'attente en attente de planification.

  • Veille légère (INTRUPTABLE) : à ce moment, le processus attend qu'un événement se produise ou qu'une ressource système réponde à un signal.

  • Veille profonde (ININTERRUPTABLE) : À ce moment, le processus attend l'apparition d'un événement ou d'une ressource système et ne peut pas répondre au signal.

État d'arrêt (STOPPED) : le processus est suspendu à ce moment.

    Zombie state (ZOMBIE) : Pour le moment, le processus ne peut pas être planifié, mais le PCB n'a pas été libéré.
  • État de mort (DEAD) : il s'agit d'un processus terminé et le PCB sera libéré
  • 1.2.2 Mode utilisateur/mode noyau
  • Mode noyau : également appelé

    espace noyau

    , est la zone où se trouve le processus/thread du noyau. Principalement responsable de l’interaction du système d’exploitation et du matériel.
  • Mode utilisateur : Également appelé
  • Espace utilisateur

    , c'est la zone où se trouvent les processus/threads utilisateur. Principalement utilisé pour exécuter des programmes utilisateur.

  • 1. Différence
  • Mode noyau : le code en cours d'exécution n'est soumis à aucune restriction et le CPU peut exécuter n'importe quelle instruction.

    Mode utilisateur :
  • ne peut pas planifier le CPU et ne peut pas accéder directement au matériel
. Le code en cours d'exécution doit être soumis à de nombreuses vérifications par le processeur et ne peut pas accéder directement aux données et aux programmes du noyau, c'est-à-dire qu'il ne peut accéder à aucune adresse valide comme un thread en mode noyau.

Linux peut-il créer plusieurs processus ?Lorsque le système d'exploitation exécute des programmes utilisateur, il fonctionne principalement en mode utilisateur. Il ne passe en mode noyau que lorsqu'il exécute des tâches qu'il n'est pas autorisé à accomplir.

2. Raisons de la distinction entre le mode utilisateur et le mode noyau


Mécanisme de protection pour empêcher les processus utilisateur contre un mauvais fonctionnement ou des dommages malveillants au système

Linux peut-il créer plusieurs processus ?Assurer une gestion centralisée des ressources et réduire les conflits d'utilisation des ressources.


3. Passer du mode utilisateur au mode noyau
(1) Appel système (actif)

L'appel système (appel système) est une interface fournie par le système d'exploitation au processus utilisateur pour demander au système d'exploitation pour effectuer certaines opérations privilégiées, c'est-à-dire la fenêtre qui fournit des services aux processus utilisateur. Sous Linux, vous pouvez utiliser la commande man syscalls pour afficher toutes les interfaces API d'appel système fournies par Linux.

Étant donné que l'état utilisateur ne peut pas effectuer certaines tâches, l'état utilisateur demandera de passer à l'état du noyau, et l'état du noyau termine le changement via des interruptions spécialement ouvertes pour les utilisateurs.

(2) Interruption du périphérique (passif)

    Le périphérique envoie un signal d'interruption lorsque l'interruption se produit, le processus en cours d'exécution est suspendu et le processus d'interruption est traité par le noyau du système d'exploitation si le processeur était en cours d'exécution. l'utilisateur avant l'interruption Un programme d'état équivaut à passer de l'état utilisateur à l'état noyau.
  • Les interruptions sont utilisées pour garantir que le contrôle du processeur est transféré au système d'exploitation afin que le système d'exploitation puisse effectuer certaines opérations.

  • (3) Exception (passive)
    Lorsqu'une exception inconnue se produit lors de l'exécution du programme utilisateur, elle passera du programme utilisateur au programme du noyau qui gère l'exception, c'est-à-dire qu'elle passera à l'état du noyau .

    1.3 Fonction d'interface de processus

    1.3.1 Création de processus fork/vfork

    1, fork(), vfork()
    (1) Le processus nouvellement créé est appelé processus enfant, qui copie toutes les ressources du parent processus (Il n'est copié qu'une seule fois au moment de la création. Après , la valeur de la variable globale sera différente ). On ne sait pas lequel des processus parent et enfant vient en premier.

    #include <unistd.h>
    pid_t fork(void);
      		返回值:  > 0表示处于父进程中 这个时候的返回值就是**子进程进程id号**
                      ==0 表示处于子进程中
                      < 0 创建进程出错
                      
    #include <sys/types.h>
      		 #include <unistd.h>
    		pid_t vfork(void);

    (2) **vfork()** Le processus enfant partage toutes les ressources du processus parent Il faut que le processus enfant s'exécute en premier, puis le processus parent s'exécute (même si vous ajoutez sleep(. ) pour interférer artificiellement C'est également inutile)
    (3) Remarque
    Le résultat de l'utilisation de exit() dans le processus enfant est complètement différent de celui de ne pas l'utiliser
    Si sleep() est utilisé dans le processus parent pour abandonner le La tranche de temps du processeur est également différente
    Que ce soit dans le processus parent En utilisant wait(), les résultats waitpid() sont également différents

    Linux peut-il créer plusieurs processus ?

    (4) Exécution de commutation de processus

    Linux peut-il créer plusieurs processus ?

    1.3.2 Sortie de processus exit/_exit

    1, exit(), _exit()

        #include <stdlib.h>
        void exit(int status); 
    	void _exit(int status);
    	参数:
              status --->进程退出时的状态
              status在实际编写程序中是可以自己约定的:
              比如:  exit(2)----》出现打开文件错误
                      exit(3)----》出现段错误(逻辑错误)
                      exit(0)----》正常退出
    		  返回:  void
    	
    	区别:
              exit()在退出的时候会刷新IO缓冲区,然后才退出(负责任的退出)
              _exit() 直接退出(不负责任的退出)

    1.3.3 Attendez que le processus enfant se termine (le processus parent recycle les ressources) wait/waitpid

    1, wait()

    	#include <sys/wait.h>
        pid_t wait(int *stat_loc);
       返回值:你回收的那个子进程的id号
       参数:stat_loc --》保存子进程退出时的状态信息(不仅仅只是返回值)
      		 stat_loc里面不仅仅只是保存了exit退出时的数值,它还保存了子进程退出时是哪个信号让它退出的,		
      	    出错了是什么原因导致的。

    Linux peut-il créer plusieurs processus ?

    2, waitpid( )

    pid_t waitpid(pid_t pid, int *stat_loc, int options); 回收子进程/进程组
        参数: pid ----》你指定要回收的那个子进程的id
               		<-1   等待进程组号为-pid中的某个子进程退出                                 					
               	   	 -1      等待任意一个子进程
                    ==0     	等待本进程组中的某个子进程退出
    			    > 0 		等待PID为pid的进程
    			stat_loc-----》存放子进程退出状态(可为NULL) 	
                options ----》一般设置为0
    						WNOHANG  当没有子进程时立即返回
    						WUNTRACED 当有子进程被暂停时立即返回
                            WCONTINUED  当有子进程收到SIGCONT立即返回
    	返回值:-1 执行失败
    			> 0 成功 返回值为被回收的进程的PID
    			0  指定了WNOHANG,且没有已退出的子进程

    1.3.4 Obtenir l'identifiant du processus – getpid

    (1)获取自己的id    getpid()
    		#include <unistd.h>
    		pid_t getpid(void);  返回值:就是该进程的id号
    (2) 获取父进程id    getppid()
             #include <unistd.h>
             pid_t getppid(void);  返回值:就是父进程的id号

    Chapitre 2 Méthode de communication multi-processus Linux

    Qu'il s'agisse d'une communication entre processus ou d'une communication entre threads. Cette phrase peut être réécrite comme suit : Résoudre le problème d'allocation des ressources partagées est son objectif fondamental, qui est de coordonner l'accès de plusieurs processus/threads aux ressources partagées

    2.1 Méthodes de communication inter-processus

    1. Méthode de communication de processus

    • Tube sans nom

    • Tube nommé

    • Signal

    2, objet IPC System V

    • Mémoire partagée

    • File d'attente de messages

    • Sémaphore

    3. BSD

  1. Prise réseau (socket)

2.1.1 Pipe sans nom

1 Caractéristiques : La méthode de communication inter-processus la plus originale
Elle ne peut être utilisée qu'entre processus avec Communication d'affinité . (processus père-enfant, processus frère);
Il n'a pas de nom (il existe
peut être créé dans le partage entre Linux et Windows (aucun fichier pipeline ne sera généré), mais les canaux nommés ne peuvent pas (Générer un fichier pipeline);
Communication semi-duplex.

2. Utilisation de canaux sans nom
(1) Créer un canal()

    #include <unistd.h>
   int pipe(int fildes[2]);
   参数:fildes[2]里面放的是两个文件描述符fildes[0],fildes[1]
         fildes[0] 读端
         fildes[1] 写端
   返回值:成功返回0    失败返回-1

(2) Envoi et réception d'informations sur le canal

myid = fork();        //创建子进程
if(myid == 0)
{
	write(fd[1],"dad,thanks!",20); //子进程向父进程发送消息
	close(fd[1]);
	close(fd[0]);
	exit(0);
}
else if(myid > 0)  
{
	read(fd[0],buf,20);   //父进程阻塞接受子进程消息
	printf("buf is:%s\n",buf);
	close(fd[1]);
	close(fd[0]);
}

2.1.2 Canal nommé (FIFO)

1 Caractéristiques : Peut être utilisé entre deux. les processus

  • ne peuvent pas être créés dans un partage entre Linux et Windows ;

  • assure l'atomicité de l'écriture (atomicité : soit ne le faites pas, soit faites-le d'un seul coup sans interférence du monde extérieur

    ) ;
  • Les tubes célèbres ne peuvent pas être écrasés et créés (Le code général utilise la fonction access() pour déterminer s'il existe. Si un tube du même nom existe déjà, il ne peut pas être recréé

  • N'oubliez pas de le faire) ; fermez-le après utilisation

  • Lorsque le canal est ouvert en mode lecture seule, il sera bloqué jusqu'à ce qu'un autre processus ouvre le canal en mode écriture seule, alors il ne sera pas bloqué s'il l'est ; ouvert en mode lecture-écriture, il ne sera pas bloqué.

  • Communication full-duplex, semi-duplex.

2. Utilisation de tubes célèbres
(1) Créer mkfifo()

   #include <sys/types.h>
   #include <sys/stat.h>
   int mkfifo(const char *pathname, mode_t mode);
  参数:pathname 有名管道的路径名
       	mode:权限  0666
	  返回值:0 成功
			  -1 失败

(2) Envoi et réception d'informations de processus FIFO

fifo_read.c :-----------》

#define FIFO1  "myfifo1"
#define FIFO2  "myfifo2"
int main(void) {
	int my_fd,fd1,fd2;
	char r_buff[30];
    char w_buff[30];
	bzero(r_buff,30);
	
	if(access(FIFO1,F_OK)==-1) {
		my_fd = mkfifo(FIFO1,0664);	//创建管道1
		if(my_fd == -1) {
			perror("failed!\n");
			return -1;
		}
	}
	
	if(access(FIFO2,F_OK)==-1) {
		my_fd = mkfifo(FIFO2,0664);	//创建管道2
		if(my_fd == -1) {
			perror("failed!\n");
			return -1;
		}
	}
		
	fd1 = open(FIFO1,O_RDONLY); //只读打开管道1,获取管道文件描述符
	if(fd1==-1) {
		printf("open fifo1 file failed!\n");
		exit(0);
	}
	fd2 = open(FIFO2,O_WRONLY);	//只写打开管道2,获取管道文件描述符
	if(fd2==-1)	{
		printf("open fifo2 file failed!\n");
		exit(0);
	}
	
	while(1) {
		bzero(r_buff,30);
		read(fd1,r_buff,sizeof(r_buff));  //读取管道1的消息
		printf("client receive message  is: %s\n",r_buff);
		printf("client please input a message!\n");
		fgets(w_buff,30,stdin);
		write(fd2,w_buff,30);  //发送信息给管道2
	}
	close(fd2);
	close(fd1);
	
	return 0;
}

fifo_write.c :-----------》
#define FIFO1  "myfifo1"
#define FIFO2  "myfifo2"
int main(void)
{
	int my_fd,fd1,fd2;
	char w_buff[30];
	char r_buff[30];
	bzero(w_buff,30);
	if(access(FIFO1,F_OK)==-1) {
		my_fd = mkfifo(FIFO1,0664);
		if(my_fd == -1) {
			perror("failed!\n");
			return -1;
		}
	}
	
	if(access(FIFO2,F_OK)==-1) {
		my_fd = mkfifo(FIFO2,0664);
		if(my_fd == -1) {
			perror("failed!\n");
			return -1;
		}
	}
	
	fd1 = open(FIFO1,O_WRONLY);
	if(fd1==-1) {
		printf("open fifo1 file failed!\n");
		exit(0);
	}
	fd2 = open(FIFO2,O_RDONLY);
	if(fd2==-1) {
		printf("open fifo2 file failed!\n");
		exit(0);
	}
	while(1) {
		bzero(w_buff,30);
		printf("server please input a message!\n");
		fgets(w_buff,30,stdin);  
		write(fd1,w_buff,strlen(w_buff));  //写入消息到管道1文件
		read(fd2,r_buff,30);  //读取信息从管道2
		printf("server receive message is:%s\n",r_buff);
	}
	close(fd1);
	close(fd2);
	
	return 0;
}

2.1.3 Signal unique

Pendant le processus d'exécution du programme (processus) , le monde extérieur n'est pas régulier. Un signal sera envoyé au programme. A ce moment, le programme est confronté à deux choix :
L'ignorer (bloquer/ignorer)
Bloquer : signifie raccrocher le signal et attendre que le programme soit terminé. exécuter avant de répondre
Ignorer : rejeter le signal
Répondre à celui-ci

1. Quels signaux existe-t-il sous Linux : kill -l pour afficher

 1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX

(1) Les signaux n° 1 à 31 sont appelés signaux non en temps réel : les files d'attente ne sont pas prises en charge (si plusieurs signaux arrivent en même temps, la réponse sera irrégulière)
(2) Signaux définis par l'utilisateur 10) SIGUSR1 12) SIGUSR2
(3) Les signaux 34 à 64 sont appelés signaux en temps réel : ils prennent en charge les files d'attente et sont des signaux ajoutés plus tard dans le système Linux
Les signaux sont similaires aux interruptions : Matériel et logiciel
Les signaux ci-dessus en ont deux spéciaux : SIGKILL et SIGSTOP ne peuvent pas être ignorés ou bloqués

2. (1) Envoyer le signal kill()

 #include <signal.h>
 int kill(pid_t pid, int sig);
 参数:
   pid ----》进程的id
			正数:要接收信号的进程的进程号
			0:信号被发送到所有和pid进程在同一个进程组的进程
			-1:信号发给所有的进程表中的进程(除了进程号最大的进程外)
   sig ----》信号名字
   返回值:0 成功
		   -1 出错

(2) Signal de capture du signal ( )

 #include <signal.h>
 void (*signal(int sig, void (*func)(int)))(int);  // SIGKILL
         参数:sig ----》你需要捕捉的那个信号
               void (*func)(int) ----》函数指针,回调函数,捕捉到对应的信号的时候就调用该函数;第二个参数除了可以传递一个函数指针意外,还可以使用以下两个宏定义:
                SIG_IGN ---->你捕捉到的那个信号会被忽略
                SIG_DFL-----》你捕捉的信号会采用系统默认的方式响应
		返回值:成功:设置之前的信号处理方式
			出错:-1

(3) Attendre la pause du signal()

#include <unistd.h>
int pause(void);
	返回值:-1 把error值设为EINTR
			0 成功

(4)信号的阻塞
每个进程都有属于它自己的一个信号掩码(也就是该进程在运行的过程中会阻塞掉的那些信号就被称作信号掩码)。
关于信号掩码操作的一系列函数:

#include <signal.h>

  		int sigemptyset(sigset_t *set):清空信号掩码
        int sigfillset(sigset_t *set):将所有的信号添加到信号掩码中
        int sigaddset(sigset_t *set, int signum):将特定的信号添加到信号掩码中 
  		int sigdelset(sigset_t *set, int signum):将特定的信号从掩码中删除
  		int sigismember(const sigset_t *set, int signum):判断某个信号在不在该掩码中
		参数:sigset_t ----》存储被进程阻塞的信号

(5)配置信号掩码 sigprocmask()—阻塞或解除阻塞信号

    #include <signal.h>
 	int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset)
	参数:
      how ---》SIG_BLOCK 将set所包含的信号添加到原来的信号掩码中
              SIG_SETMASK 用set去替换原来的信号掩码
              SIG_UNBLOCK 将set中包含的信号从原来的掩码中删除
      set ---》新的信号掩码
      oset ---》原本的信号掩码
 				原本进程中信号掩码包含了:SIGINT ,SIGCONT

(6)捕捉指定信号并获取信号携带信息sigaction()

#include <signal.h>
int sigaction(int sig, const struct sigaction *restrict act, struct sigaction *restrict oact);
参数:
  	sig ---》你要捕捉的那个信号
    act ---》你需要捕捉的信号对应的响应函数就定义在这个结构体
    oact ---》原来的
    struct sigaction
    {
        void(*) (int)     sa_handler ----》 信号的响应函数
        sigset_t          sa_mask  ---》信号的掩码
        int               sa_flags ----》  SA_SIGINFO
        void(*) (int, siginfo_t * ,void )---》信号的响应函数
     }
	sa_flags ---》等于SA_SIGINFO,那么信号的响应函数是void(*) (int, siginfo_t * ,void )
          		不等于,那么信号的响应函数是void(*) (int) 
   siginfo_t---》/usr/include/i386-linux-gnu/bits/siginfo.h 保存的是信号的状态信息,信号的标号,发送该信号的进程的id等等这些

2.1.4 共享内存

查看共享内存: ipcs -m
删除共享内存: ipcrm -m 共享内存的id
SYSTEM-V ipc通信方式:共享内存、信号量、消息队列。

1、共享内存特点:跟mmap()思想上有些类似

  • 在进程通信方式中共享内存是效率最高的,进程可以直接读写内存,而不需要任何数据的拷贝

  • 如果代码不人为地删除共享共享内存,那么程序退出的时候它还在;

  • 多个进程共享一段内存,因此也需要依靠某种同步机制,如互斥锁和信号量等

Linux peut-il créer plusieurs processus ?

2、共享内存对应的一系列操作函数
(1)创建共享内存:shmget()

#include <sys/shm.h> 
int shmget(key_t key, size_t size, int shmflg);
返回值:成功—共享内存对象的mid(标识符) 出错—-1
参数:key----》创建共享内存需要用到的键值
      size----》内存空间的大小(字节)
      shmflg----》设置属性  IPC_CREAT   IPC_EXCL    0666组合
      
key键值的获取有两种方法:
 **方法一**:使用ftok()生成键值
            #include <sys/types.h>
            #include <sys/ipc.h>
            key_t ftok(const char *pathname, int proj_id);
            参数:pathname----》 路径名
                  proj_id----》整数
                 ftok(“.”  ,  11)  生成一个唯一的key值
            进程1:ftok(“.”  ,  11)  ----》shmget( 100);.............
       		进程2:ftok(“/home/gec”  ,  11)  ----》shmget( 106); 
				   无法通信,要确保键值一致才能通信
       
 **方法二:**不使用ftok(),程序员自己写个数字  
          shmget((key_t)1234, size_t size, int shmflg);

(2) 映射共享内存到用户空间 shmat()

#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
 返回值:成功—映射到用户空间的那片地址的首地址   出错—-1
 参数:shmid ----》使用shmget的返回值
      shmaddr----》一般设置为NULL 系统自动分配
       shmflg----》 SHM_RDONLY:共享内存只读
			        一般设置为0: 共享内存可读写 
			        if it is 0 and the calling process has read and write permission, the segment is attached for reading and writing.

(3)解除映射:shmdt()

#include <sys/shm.h>
int shmdt(const void *shmaddr);
参数:shmaddr----》 shmat()共享内存映射后的地址
返回值:成功—0 	出错—-1

(4)删除共享内存:shmctl()

 #include <sys/shm.h>
 int shmctl(int shmid, int cmd, struct shmid_ds *buf);
 参数: shmid----》共享内存的id
        cmd----》IPC_RMID    删除共享内存
                 IPC_STAT  (获取对象属性)
       			 IPC_SET (设置对象属性)
        *buf----》指定IPC_STAT/IPC_SET时保存共享内存的状态信息
		返回值:成功	失败—-1

Linux peut-il créer plusieurs processus ?

Linux peut-il créer plusieurs processus ?

3、共享内存简单示例

shm_write.c :----------》
int main() {
	int shmid;
	int *p;
	
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	
	// 映射共享内存到进程
	p = (int *)shmat(shmid,NULL,0);
	*p = 10;

	// 解除映射
	shmdt(p);
	
	// 删除内存
	//shmctl(shmid,IPC_RMID,NULL);
	return 0;
}

shm_read.c :----------》
int main() {
	int shmid;
	int *p;
	
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	
	// 映射共享内存到进程
	p = (int *)shmat(shmid,NULL,0);
	printf("p is :%d\n",*p);
	
	// 解除映射
	shmdt(p);

	// 删除内存
	shmctl(shmid,IPC_RMID,NULL);
	
	return 0;
}

2.1.5消息队列

消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等。
消息队列由消息队列ID来唯一标识
消息队列可以按照类型来发送/接收消息
消息队列的操作包括创建或打开消息队列、添加消息、读取消息和控制消息队列

Linux peut-il créer plusieurs processus ?

1、消息队列的特点
写入消息队列的信息,在编写程序的时候会人为的去设置消息的类型(用整数来表示),目的是为了其它进程在读取信息的时候能够准确地通过消息的类型判断要读取的信息。

2、消息队列操作的系列函数
(1)消息队列的创建 msgget()

 #include <sys/msg.h>
 int msgget(key_t key, int msgflg);

Linux peut-il créer plusieurs processus ?

(2)消息队列的收发信息msgsnd()msgrcv()

 #include <sys/msg.h>
 int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
	参数:void *msgp ----》你要发送信息就存储在这个指针中
                  在实际的编程中我们都是定义一个结构体来存储信息
                  struct msgbuf {
                      long mtype;  ----》消息的类型
                      char mtext[100]; ----》消息的内容
                    }
                    msgsz ----》消息的长度,大小
                    msgflg ----》设置为0    除开以上三种宏定义之外的----阻塞读写

Linux peut-il créer plusieurs processus ?

(3)消息队列的删除 msgctl()

#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

Linux peut-il créer plusieurs processus ?

3、消息队列通信简单示例

pthread1.c :-----------》
#define SIZE 64
//数据接收结构体
struct msg_rv
{
	int mtype;
	char msg[50];
	
};

//数据发送结构体
struct msg_snd
{
	int mtype;
	char msg[50];
};

int main(void) {
	int msgid;
	struct msg_rv data;
	struct msg_snd snddata;
	char buff[50];

	//获取msgid
	msgid = msgget((key_t)123,IPC_CREAT|0666);
	if(msgid == -1)	{
		printf("msgid failed!\n");
		return -1;
	}

	data.mtype = 88;
	snddata.mtype = 89;
	
	while(1) {
		bzero(buff,50);
		printf("please input data!\n");
		fgets(buff,50,stdin);	
		strcpy(snddata.msg,buff);
		if(strncmp(snddata.msg,"end",3)==0) {
			break;
		}
		
		msgsnd(msgid,(void *)&snddata,strlen(buff)+4,0);//得到的值发送出去
		usleep(20);
		printf("run here!\n");
		
		if(msgrcv(msgid,(void *)&data,sizeof(struct msg_rv),data.mtype,0)==-1) {
			printf("msgsnd failed!\n");
			return -1;
		}
		
		printf("receive data:%s\n",data.msg);
		if(strncmp(data.msg,"end",3)==0) {
			break;	
		}	
	}
	
	//撤消消息队列
	msgctl(msgid,IPC_RMID,0);
	return 0;
}

pthread2.c :------------------------》
#define SIZE 64
//数据接收结构体
struct msg_rv
{
	int mtype;
	char msg[50];
	
};

//数据发送结构体
struct msg_snd
{
	int mtype;
	char msg[50];
};

int main(void)
{
	int msgid;
	struct msg_rv data;
	struct msg_snd snddata;
	char buff[50];
	
	data.mtype = 89;
	snddata.mtype = 88;
		
	//获取msgid
	msgid = msgget((key_t)123,IPC_CREAT|0666);
	if(msgid == -1)	{
		printf("msgid failed!\n");
		return -1;
	}
	
	while(1) {	
		//接受
		if(msgrcv(msgid,(void *)&data,sizeof(struct msg_rv),data.mtype,0)==-1)
		{
			printf("msgsnd failed!\n");
			return -1;
		}
		printf("receive data:%s\n",data.msg);
		if(strncmp(data.msg,"end",3)==0) {
			break;
		}
		
		//发送
		printf("please input data:\n");
		bzero(buff,50);
		fgets(buff,50,stdin);
		strcpy(snddata.msg,buff);
		printf("data = %s\n",snddata.msg);
		if(strncmp(snddata.msg,"end",3)==0) {
			break;
		}
		msgsnd(msgid,(void *)&snddata,strlen(buff)+4,0);//得到的值发送出去
		printf("run here!\n");	
	}
	
	//撤消消息队列
	msgctl(msgid,IPC_RMID,0);
	return 0;
}

2.1.6 信号量

信号量协调不同进程对于共享资源的访问,它是不同进程间或一个给定进程内部不同线程间同步的机制。

Linux peut-il créer plusieurs processus ?

1、信号量概述
(1)二值信号量
值为0或1。与互斥锁类似,资源可用时值为1,不可用时值为0
(2)计数信号量
值在0到n之间。用来统计资源,其值代表可用资源数
(3)对信号量的操作
P操作:即申请资源,亦即将信号量值减1,可能引起进程睡眠。
V操作:即释放资源,亦即将信号量值加1,V操作从不会睡眠。
等0操作:不申请也不释放资源,而是令进程阻塞直到信号量的值为0为止

2、信号量相关的接口函数
(1) 创建信号量集合semget()

#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
    参数:key ----》键值
          nsems----》你创建的信号量集中信号量的个数
          semflg----》 IPC_CREAT|0666组合
	返回值:成功—信号量ID
			出错—-1

(2)设置/删除信号量集 semctl()

   #include <sys/sem.h>
      int semctl(int semid, int semnum, int cmd, ...);
	  返回值:成功—0 	失败—-1

Linux peut-il créer plusieurs processus ?

(3)信号量的PV操作 semop()
核心:信号量为 p 减一操作
v 加一操作

  #include <sys/sem.h>
  int semop(int semid, struct sembuf *sops, size_t nsops);
  返回值:成功—0   出错—-1
  参数:semid ----》semget的返回值
        nsops ---》要操作的信号量的个数(结构体的个数)
  		sops---》信号量操作结构体
		struct sembuf {
			short  sem_num	;=>> 要操作的信号量的编号(数组下标)
			short  sem_op;   =>> 0 :  等待,直到信号量的值变成0
                            	1 :  释放资源,V操作
                           		-1 :  分配资源,P操作                    
			short  sem_flg;   =>> 0/IPC_NOWAIT/SEM_UNDO
								SEM_UNDO: 程序结束时(不论正常或不正常),保证信号值会被重设为semop()调用前的值;
								IPC_NOWAIT: 对信号的操作不能满足时,semop()不会阻塞,并立即返回,同时设定错误信息;
		};

3、信号量协同共享内存示例代码

pthread1.c  :-----------》

int main()
{
	int semid;
	int shmid;
	char *p;
	struct sembuf mysembuf1,mysembuf2;
	
	mysembuf1.sem_num = 0;
	mysembuf1.sem_flg = SEM_UNDO;
	mysembuf1.sem_op = 1;
	
	mysembuf2.sem_num = 1;
	mysembuf2.sem_flg = SEM_UNDO;
	mysembuf2.sem_op = -1;
	
	// 创建信号量集合
	semid = semget((key_t)789,2,IPC_CREAT|0666);
	if(semid == -1)	{
		perror("creat sem failed!\n");
		return -1;
	}
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	// 映射共享内存到进程
	p = (char *)shmat(shmid,NULL,0);

	while(1) {
		semop(semid,&mysembuf2,1); // 对信号量2进行p操作(减一)
		printf("the message I recv is:%s\n",p);
		printf("please input a message!\n");
		scanf("%s",p);
		printf("message is %s\n",p);
		semop(semid,&mysembuf1,1); // 对信号量1进行v操作(加一)
	}
	
	//解除映射 
	shmdt(p);
	
	//删除共享内存
	shmctl(semid, IPC_RMID, NULL); 
}

pthread2.c  :-----------》
int main() {
	int semid;
	int shmid;
	char *p;
	struct sembuf mysembuf1,mysembuf2;
	
	mysembuf1.sem_num = 0;  // 信号集合中的第一个信号
	mysembuf1.sem_flg = SEM_UNDO;
	mysembuf1.sem_op = -1;   //p操作

	mysembuf2.sem_num = 1;  // 信号集合中的第二个信号
	mysembuf2.sem_flg = SEM_UNDO;
	mysembuf2.sem_op = 1;    // v操作
	// 创建信号量集合
	semid = semget((key_t)789,2,IPC_CREAT|0666);
	if(semid == -1)	{
		perror("creat sem failed!\n");
		return -1;
	}
	// 设置信号量的值
	semctl(semid,0,SETVAL,1);  //第一个信号量初值为1
	printf("sem num is:%d\n",semctl(semid,0,GETVAL));
	semctl(semid,1,SETVAL,0);  //第二个信号量初值为0
	printf("sem num is:%d\n",semctl(semid,1,GETVAL));
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	// 映射共享内存到进程
	p = (char *)shmat(shmid,NULL,0);
	while(1) {
		semop(semid,&mysembuf1,1); // 对信号量1进行p操作(减一)不阻塞,因为初值为1
		  // 执行完这句话以后信号量的值就立马变成1
		printf("the message I recv is:%s\n",p); 
		printf("please input a message!\n");
		scanf("%s",p);
		printf("message is %s\n",p);
		semop(semid,&mysembuf2,1); // 对信号量2进行v操作(加一)不阻塞,因为初值为0	
	}
	
	//解除映射 
	shmdt(p);
	
	//删除共享内存
	shmctl(semid, IPC_RMID, NULL);
}

2.3 IPC shell命令操作

  • ipcs -q 查看消息队列

  • ipcrm -q MSG_ID 删除消息队列

  • ipcs -m 查看共享内存

  • ipcrm -m SHM_ID Supprimer la mémoire partagée

  • ipcs -s Afficher le sémaphore

  • ipcrm -s SEM_ID Supprimer le sémaphore

2.2 Comparaison des méthodes de communication inter-processus

  • pipe : inter-processus avec affinité, simplex, données en mémoire

  • fifo : peut être utilisé pour tout inter-processus, duplex, avec nom de fichier, données en mémoire

  • signal : méthode de communication asynchrone unique

  • msg : souvent utilisé en mode cs, accessible par type de message, peut être prioritaire

  • shm : le plus efficace (accès direct à la mémoire), nécessite un mécanisme de synchronisation et d'exclusion mutuelle

  • sem : coopération Partagé la mémoire est utilisée pour réaliser la synchronisation et l'exclusion mutuelle

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!

Déclaration:
Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer