Chiamare la funzione getpid in C con esempi

Getpid () è la funzione utilizzata per ottenere l'ID processo del processo che chiama quella funzione. Il PID per il processo iniziale è 1, quindi a ciascun nuovo processo viene assegnato un nuovo ID. È un approccio semplice per ottenere il PID. Questa funzione ti aiuta solo a ottenere gli ID dei processi univoci.

Funzioni utilizzate per ottenere ID

Qui sono presenti due tipi di ID. Uno è l'ID corrente del PID di processo. Mentre l'altro è l'ID del processo genitore PPID. Entrambe queste funzioni sono funzioni integrate che sono definite in libreria. Durante l'esecuzione del codice senza utilizzare questa libreria può causare un errore e interrompe l'esecuzione.

funzione getpid () in c

Quando si forma un processo e viene eseguito, viene assegnato un ID univoco. Questo è l'ID del processo. Questa funzione aiuta a restituire l'ID del processo che viene attualmente chiamato.

funzione getppid () in c

Questo ID è utile per restituire il processo del processo/funzione genitore.

Esempio 1
Per comprendere l'esempio del PID nel processo nella lingua C. Hai bisogno di due strumenti: qualsiasi editor di testo e terminale Linux, su cui dovresti eseguire i comandi. Crea un file in qualsiasi editor di testo. Abbiamo creato un codice nome file1.C poiché il codice è scritto in lingua C, quindi dovrebbe essere salvato con il .estensione c.

Abbiamo aggiunto una sola libreria. Quindi qui inizia il programma principale. Nel programma principale, chiamiamo la funzione integrata getPid (); per recuperare l'ID del processo corrente. E una variabile viene introdotta e assegnata. In modo che il valore della funzione PID () sia memorizzato in questa variabile, quindi prenderemo la stampa del valore usando questa variabile.

Ora vogliamo eseguire il contenuto di questo file nel terminale Linux. Il prerequisito del codice deve essere compilato per primo e quindi eseguire. Per la compilazione, viene utilizzato GCC. Se il tuo sistema manca GCC, è necessario installarlo prima utilizzando il comando sudo.

Ora compila il codice scritto. Ciò può essere realizzato utilizzando il seguente comando aggiunto.

$ Gcc -o code1 code1.C

Mentre -o viene utilizzato per aprire il file di salvataggio nel comando. Quindi dopo -o, scriviamo il nome file.

Dopo la compilazione, eseguire il comando.

$ ./Code1

L'immagine sopra mostra l'ID processo della funzione.

Esempio 2
Nell'esempio precedente, utilizziamo il PID. Ma in questo esempio, vengono utilizzati sia il PID che il PPID. Il codice sorgente per questa funzione è quasi lo stesso di quello precedente. Solo c'è un'altra aggiunta di un ID.

Considera un file che contiene due variabili nel programma principale assegnato dagli ID di processo. Uno è del processo attuale e l'altro è del processo genitore. Quindi simile al primo esempio, stampare entrambi gli ID attraverso le loro variabili.

Int pid_t = getpid ();
Int ppid_t = getppid ();

Questi due sono le funzioni principali dell'intero codice. Ora, dopo la creazione di file, il prossimo passo è compilare ed eseguire il file. Compila usando GCC nel comando. Dopo la compilazione, quindi eseguilo sul terminale di Ubuntu.

$ Gcc -o code1 code1.C
$ ./Code1

L'output mostra che l'ID di processo viene visualizzato prima, quindi viene visualizzato l'ID processo principale.

Esempio 3
Tutti i processi eseguono ed eseguono in modo parallelo. Il genitore e i processi figlio eseguono collettivamente tutte le righe rimanenti. Entrambi danno risultati alla volta. Ma usando una forchetta nel codice C, se questa funzione restituisce un valore inferiore a 0, significa che la chiamata di funzione viene terminata.

Prendi in considerazione un nuovo file con due librerie nella rispettiva intestazione. Qui viene utilizzata una condizione in cui abbiamo utilizzato l'istruzione "if-else". Nel programma principale, si afferma che se il valore della forcella è in valore -ive, visualizzerà un messaggio che l'ID del processo non riesce e non verrà ottenuto. Se la situazione è falsa, il compilatore si sposterà nella parte altro della condizione. In questa parte, si ottiene l'ID processo, visualizzeremo questo ID di processo e visualizzeremo un messaggio che si ottiene l'ID processo. Qui citeremo l'istruzione if-else del codice sorgente.

Ora di nuovo, compila il codice e poi eseguilo.

./code2

L'output mostra che la parte altro è stata eseguita e stamperà l'ID processo e quindi visualizzerà un messaggio PID.

Esempio 4

Questo è un altro esempio di spiegare lo stesso concetto. La funzione fork () restituisce due valori diversi. Nel caso di un processo figlio, il valore è 0, che deve essere restituito. Allo stesso tempo, il valore nel caso del processo genitore è l'ID processo del nuovo figlio.

In questo esempio, viene utilizzata la stessa condizione if_else. Ma qui vengono applicate due condizioni. Confrontare il PID che è inferiore a zero e l'altro è uguale a zero. Se il PID è inferiore a zero, mostrerà un messaggio di errore. Mentre se il PID è uguale a zero, significa che si tratta di un processo figlio e la parte altro mostra che se il PID è maggiore di zero, è un processo genitore.

Ora compila ed esegui il codice.

$ gcc -o code3 code3.C
$./Code3

Dall'output, possiamo vedere che la parte altro è stampata prima significa che l'ID di processo è maggiore di 0.

Esempio 5
Va bene, questo è l'ultimo esempio in cui abbiamo cercato di riassumere tutti i codici sopra descritti per spiegare il funzionamento di questa funzione. Possiamo anche utilizzare i loop con le funzioni FORK () per utilizzare le funzioni getPid (). Possiamo usare i loop per creare molti processi per bambini. Qui dobbiamo usare il valore di 3 nel ciclo.

Ancora una volta dobbiamo utilizzare l'istruzione condizionale nel codice. Il ciclo per inizia dall'uno e iteri fino a 3^Rd giro.

Ora salva il file ed eseguilo. C'è un altro metodo semplice per compilare ed eseguire il codice solo in un singolo comando. Questo è.

Codici $ GCC5.c -o s & ./code5

Ora spostandosi verso l'output del codice. L'ID del processo genitore è identico in tutti i processi figlio. Questo significa che tutti questi processi appartengono a un genitore. Questi processi vengono eseguiti uno dopo l'altro poiché il ciclo è limitato a 3. Verranno fatte solo 3 iterazioni.

Conclusione

Questo articolo contiene le conoscenze di base e il funzionamento di una funzione getpid () nei comandi Linux. L'ID univoco viene assegnato a ciascun processo attraverso questa funzione.