Heim > Artikel > Betrieb und Instandhaltung > Kann Linux mehrere Prozesse erstellen?

Kann Linux mehrere Prozesse erstellen?

王林nach vorne: 2023-05-20 18:32:461482Durchsuche

Linux kann mehrere Prozesse erstellen. Linux kann mehrere Aufgaben gleichzeitig erledigen und mehrere Prozesse unterstützen, um die Nutzung der Systemressourcen zu maximieren. Kommunikationsmethoden zwischen Linux-Prozessen: 1. Unbenannte Pipes verwenden (FIFO);

Linux kann mehrere Prozesse erstellen.

linux unterstützt mehrere Prozesse. Ein Vorteil eines Multiprozesssystems besteht darin, dass es mehrere Aufgaben gleichzeitig bearbeiten kann, um eine maximale Auslastung der Systemressourcen zu erreichen.

Kapitel 1 Einführung in Linux-Multiprozesse

1.1 Übersicht

1.1 .1 Prozesskonzept

Unter Linux wird das laufende Programm als Prozess bezeichnet.
Programm : Statisches Konzept, es ist eine kompilierte Binärdatei
Prozess : Dynamisches Konzept, wenn das Programm ausgeführt wird, wird das System automatisch Führen Sie einen entsprechenden Prozess aus
Der Prozess besteht aus drei Teilen: Prozesskontrollblock (PCB), Codesegment und Datensegment
Prozesskontrollblock: Wird in Linux verwendet. Dargestellt durch eine Struktur , Aufzeichnen der Statusinformationen des Prozesses
Zombie-Prozess : Der übergeordnete Prozess wird vor dem untergeordneten Prozess beendet
Wenn Sie einen untergeordneten Prozess erstellen, sind im übergeordneten Prozess jedoch die Ressourcen vorhanden des untergeordneten Prozesses nicht recycelt werden, wird der untergeordnete Prozess zu einem Zombie-Prozess und der Zombie-Prozess wird schließlich von einem Prozess namens INIT im System recycelt.
Der Init-Prozess (Prozess Nr. 1) ist der erste Prozess, der beim Systemstart ausgeführt wird, und der Vorgängerprozess aller Prozesse.

1.1.2 Prozessansicht-Shell-Befehl

top Dynamische Prozessinformationen anzeigen# 🎜 🎜#
ps -ef Prozessdetails anzeigen
#🎜🎜 #pstree# 🎜🎜# Prozessinformationen in Baumform anzeigen
Den angehaltenen Prozess im Hintergrund ausführen lassen# 🎜🎜##🎜 🎜#
1.2 Prozessausführungsstatus

1.2.1 Ausführungsstatus

#🎜 🎜##🎜🎜 #Ausführungsstatus (RUNNING): Der Prozess belegt die CPU.

Bereitschaftszustand (RUNNING): Der Prozess befindet sich in der Warteschlange und wartet auf die Planung.

Leichter Schlaf (UNTERBRUCHBAR): Zu diesem Zeitpunkt wartet der Prozess darauf, dass ein Ereignis eintritt oder eine Systemressource auf ein Signal reagiert.
Tiefschlaf (UNUNTERBRECHENBAR): Zu diesem Zeitpunkt wartet der Prozess auf das Eintreten eines Ereignisses oder einer Systemressource und kann nicht auf das Signal reagieren.
STOPPED: Der Prozess ist zu diesem Zeitpunkt angehalten.
Zombie-Status (ZOMBIE): Derzeit kann der Prozess nicht geplant werden, aber die Leiterplatte wurde nicht freigegeben.
DEAD: Dies ist ein beendeter Prozess und die Leiterplatte wird freigegeben
#🎜 🎜#
# 🎜🎜#
Kernelmodus: auch
Kernelraum

Benutzermodus: Auch

Benutzerbereich Kann Linux mehrere Prozesse erstellen? genannt, ist der Bereich, in dem sich Benutzerprozesse/-threads befinden. Wird hauptsächlich zum Ausführen von Benutzerprogrammen verwendet.

1. Unterschied
Kernelmodus: Der laufende Code unterliegt keinen Einschränkungen, und der Die CPU kann jede Anweisung ausführen. Benutzermodus:

kann die CPU nicht planen und nicht direkt auf die Hardware zugreifen

. Der laufende Code muss zahlreichen Prüfungen durch die CPU unterzogen werden und kann nicht direkt auf Kerneldaten und -programme zugreifen, d. h. er kann nicht wie ein Kernel-Modus-Thread auf eine gültige Adresse zugreifen. Kann Linux mehrere Prozesse erstellen?

Wenn das Betriebssystem Benutzerprogramme ausführt, arbeitet es hauptsächlich im Benutzermodus. Es wechselt nur dann in den Kernelmodus, wenn es Aufgaben ausführt, zu deren Ausführung es keine Berechtigung hat.

2. Gründe für die Unterscheidung zwischen Benutzermodus und Kernelmodus

Schutzmechanismus, um Fehlbedienungen von Benutzerprozessen zu verhindern oder Es handelt sich um eine böswillige Beschädigung des Systems

, um eine zentrale Verwaltung der Ressourcen sicherzustellen und Konflikte bei der Ressourcennutzung zu reduzieren.

3. Vom Benutzermodus in den Kernelmodus wechseln
(1) Systemaufruf (aktiv)# 🎜🎜#
Systemaufruf (Systemaufruf) ist eine Schnittstelle, die das Betriebssystem dem Benutzerprozess bereitstellt, um das Betriebssystem aufzufordern, einige privilegierte Vorgänge auszuführen, dh ein Fenster, das dem Benutzerprozess Dienste bereitstellt. Unter Linux können Sie den Befehl man syscalls verwenden, um alle von Linux bereitgestellten Systemaufruf-API-Schnittstellen anzuzeigen.
Da der Benutzerstatus bestimmte Aufgaben nicht ausführen kann, fordert der Benutzerstatus den Wechsel zum Kernelstatus an, und der Kernelstatus schließt den Wechsel durch speziell für Benutzer geöffnete Interrupts ab.

(2) Peripheriegerät-Interrupt (passiv) Das Peripheriegerät sendet ein Interrupt-Signal, wenn der Interrupt auftritt, wird der aktuell laufende Prozess angehalten und ausgeführt Wenn die CPU vor dem Interrupt ein Benutzermodusprogramm ausführt, entspricht dies dem Wechsel vom Benutzermodus in den Kernelmodus.
Interrupts werden verwendet, um sicherzustellen, dass die CPU-Steuerung an das Betriebssystem übergeben wird, damit das Betriebssystem bestimmte Vorgänge ausführen kann.

(3) Ausnahme (passiv)
Wenn beim Ausführen des Benutzerprogramms eine unbekannte Ausnahme auftritt, wechselt es vom Benutzerprogramm zu dem Programm im Kernel, das die Ausnahme behandelt, dh es wechselt in den Kernel-Status .

1.3 Prozessschnittstellenfunktion

1.3.1 Prozesserstellung fork/vfork

1, fork(), vfork()
(1) Der neu erstellte Prozess wird als untergeordneter Prozess bezeichnet, der alle Ressourcen des kopiert übergeordneter Prozess (Er wird zum Zeitpunkt der Erstellung nur einmal kopiert. Nach wird der globale Variablenwert unterschiedlich sein Es ist ungewiss, welcher der übergeordneten und untergeordneten Prozesse zuerst kommt.

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

(2) **vfork()** Der untergeordnete Prozess teilt alle Ressourcen des übergeordneten Prozesses. Es muss sein, dass der untergeordnete Prozess zuerst ausgeführt wird und dann der übergeordnete Prozess ausgeführt wird (auch wenn Sie Sleep hinzufügen). ) künstlich einzugreifen Es ist auch nutzlos) (3) Hinweis
Das Ergebnis der Verwendung von exit() im untergeordneten Prozess ist völlig anders als das Ergebnis, wenn es nicht verwendet wird
Unabhängig davon, ob sleep() im übergeordneten Prozess verwendet wird, um aufzugeben Die CPU-Zeitscheibe ist ebenfalls unterschiedlich
Ob im übergeordneten Prozess Die Ergebnisse von wait() und waitpid() sind ebenfalls unterschiedlich
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 Warten, bis der untergeordnete Prozess beendet wird (der übergeordnete Prozess recycelt Ressourcen) wait/waitpid Kann Linux mehrere Prozesse erstellen?

1, wait()

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

Kann Linux mehrere Prozesse erstellen? 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 Holen Sie sich die ID des Prozesses – getpid

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

Kapitel 2 Linux-Multiprozess-Kommunikationsmethode

Ob es sich um Kommunikation zwischen Prozessen oder Kommunikation zwischen Threads handelt. Dieser Satz kann wie folgt umgeschrieben werden: Die Lösung des Zuordnungsproblems gemeinsam genutzter Ressourcen ist sein grundlegender Zweck, der darin besteht, den Zugriff mehrerer Prozesse/Threads auf gemeinsam genutzte Ressourcen zu koordinieren

Kann Linux mehrere Prozesse erstellen? 2.1 Kommunikationsmethoden zwischen Prozessen

1. Prozesskommunikationsmethode: Unbenannte Pipe

Semaphor

3. BSD

Netzwerk-Socket (Socket)

2.1.1 Unbenannte Pipe-Pipe
1. Merkmale: Die originellste prozessübergreifende Kommunikationsmethode
Affinitätskommunikation
verwendet werden (Vater-Kind-Prozess, Geschwisterprozess);
Es hat keinen Namen (es existiert);
Halbduplex-Kommunikation.
2. Verwendung unbenannter Pipes

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

(2) Pipe-Informationen senden und empfangen

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]);
}

1 zwei Prozesse
können nicht in einer Freigabe zwischen Linux und Windows erstellt werden;
stellt die Atomizität des Schreibens sicher (Atomizität: entweder nicht ausführen oder in einem Durchgang ohne Einmischung der Außenwelt ausführen);

Berühmte Pipes

können nicht überschrieben und erstellt werden

Wenn die Pipe im
schreibgeschützten-Modus geöffnet wird, wird sie blockiert, bis ein anderer Prozess die Pipe im schreibgeschützten
-Modus öffnet Im Lese-/Schreibmodus geöffnet, wird es nicht blockiert.

Vollduplex-Kommunikation, Halbduplex. 2. Verwendung berühmter Pipes. , die Außenwelt ist nicht normal. Es wird ein Signal an das Programm gesendet. Zu diesem Zeitpunkt hat das Programm zwei Möglichkeiten:
Ignorieren (Blockieren/Ignorieren)

Blockieren: bedeutet, das Signal aufzulegen und zu warten, bis das Programm beendet ist ausgeführt, bevor reagiert wird.

Ignorieren: Signal verwerfen.

Darauf reagieren. Warteschlangen werden nicht unterstützt (wenn mehrere Signale gleichzeitig eintreffen, ist die Reaktion unregelmäßig)

(2) Benutzerdefinierte Signale 10) SIGUSR1 12) SIGUSR2

(3) Die Signale 34 bis 64 werden als Echtzeitsignale bezeichnet: sie Unterstützungswarteschlangen und Signale, die später im Linux-System hinzugefügt werden

Signale ähneln Interrupts: Hardware und Software

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

(2) Signal erfassen ( )

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;
}

#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等等这些