Bagaimana Siklus Hidup Proses Linux Bekerja – Proses Induk, Anak, dan Init

Sebuah proses tidak lain adalah contoh program yang sedang berjalan. Hal ini juga didefinisikan sebagai program dalam tindakan.

Konsep proses adalah konsep dasar dari sistem Linux. Proses dapat menelurkan proses lain, membunuh proses lain, berkomunikasi dengan proses lain dan banyak lagi.

Dalam tutorial ini, kita akan membahas siklus hidup suatu proses dan sentuhan berdasarkan berbagai aspek yang dilalui suatu proses dalam siklus hidupnya.

1. Kode Vs Program Vs Proses

Mari kita pahami dulu perbedaan antara kode, program, dan proses.

Kode: Berikut adalah contoh kodenya :

#include <stdio.h>
#include <unistd.h>

int main(void)
{
    printf("\n Hello World\n");
    sleep(10);

    return 0;
}

Mari kita simpan potongan kode di atas dalam file bernama helloWorld.c. Jadi file ini menjadi kode.

Program: Sekarang, ketika kode dikompilasi, itu menghasilkan file yang dapat dieksekusi. Berikut adalah bagaimana kode di atas dikompilasi :

$ gcc -Wall helloWorld.c -o helloWorld

Ini akan menghasilkan executable bernama helloWorld. Eksekusi ini dikenal sebagai program.

Proses: Sekarang, mari kita jalankan executable ini :

$ ./helloWorld 

 Hello World

Setelah dijalankan, proses yang sesuai dengan executable (atau program) ini dibuat. Proses ini akan mengeksekusi semua kode mesin yang ada di dalam program. Inilah alasan mengapa suatu proses dikenal sebagai menjalankan instance dari suatu program.

Untuk memeriksa detail proses yang baru dibuat, jalankan perintah ps dengan cara berikut :

$ ps -aef | grep hello*
1000      6163  3017  0 18:15 pts/0    00:00:00 ./helloWorld

Untuk memahami output dari perintah ps, baca artikel kami tentang contoh perintah 7 ps.

2. Proses Induk dan Anak

Setiap proses memiliki proses induk dan mungkin atau mungkin tidak memiliki proses anak. Mari kita ambil ini satu per satu. Pertimbangkan output dari perintah ps pada mesin Ubuntu saya :

1000      3008     1  0 12:50 ?        00:00:23 gnome-terminal
1000      3016  3008  0 12:50 ?        00:00:00 gnome-pty-helper
1000      3017  3008  0 12:50 pts/0    00:00:00 bash
1000      3079  3008  0 12:58 pts/1    00:00:00 bash
1000      3321     1  0 14:29 ?        00:00:12 gedit
root      5143     2  0 17:20 ?        00:00:04 [kworker/1:1]
root      5600     2  0 17:39 ?        00:00:00 [migration/1]
root      5642     2  0 17:39 ?        00:00:00 [kworker/u:69]
root      5643     2  0 17:39 ?        00:00:00 [kworker/u:70]
root      5677     2  0 17:39 ?        00:00:00 [kworker/0:2]
root      5680     2  0 17:39 ?        00:00:00 [hci0]
root      5956   916  0 17:39 ?        00:00:00 /sbin/dhclient -d -sf /usr/lib/NetworkManager/nm-dhcp-client.action -pf /run/sendsigs.
root      6181     2  0 18:35 ?        00:00:00 [kworker/1:0]
root      6190     2  0 18:40 ?        00:00:00 [kworker/1:2]
1000      6191  3079  0 18:43 pts/1    00:00:00 ps -aef

Bilangan bulat di kolom kedua dan ketiga dari output di atas mewakili ID proses dan ID proses induk. Perhatikan angka-angka yang disorot dalam huruf tebal. Ketika saya menjalankan perintah 'ps -aef', sebuah proses telah dibuat, ID prosesnya adalah 6191. Sekarang, lihat ID proses induknya, itu adalah 3079. Jika Anda melihat ke awal output Anda akan melihat bahwa ID 3079 adalah ID proses dari proses bash. Ini menegaskan bahwa bash shell adalah induk untuk setiap perintah yang Anda jalankan melaluinya.

Demikian pula, bahkan untuk proses yang tidak dibuat melalui shell, ada beberapa proses induk. Jalankan saja perintah 'ps -aef' di mesin Linux Anda dan amati kolom PPID (parent process ID). Anda tidak akan melihat entri kosong di dalamnya. Ini menegaskan bahwa setiap proses memiliki proses induk.

Sekarang, mari kita masuk ke proses anak. Setiap kali suatu proses membuat proses lain, yang pertama disebut induk sedangkan yang terakhir disebut proses anak. Secara teknis, proses anak dibuat dengan memanggil fungsi fork() dari dalam kode. Biasanya ketika Anda menjalankan perintah dari shell, fork() diikuti oleh rangkaian fungsi exec().

Kami membahas bahwa setiap proses memiliki proses induk, ini dapat menimbulkan pertanyaan bahwa apa yang akan terjadi pada proses anak yang proses induknya dimatikan? Nah, ini pertanyaan yang bagus tapi mari kita kembali lagi nanti.

3. Proses init

Ketika sistem Linux di-boot, Hal pertama yang dimuat ke dalam memori adalah vmlinuz. Ini adalah kernel Linux terkompresi yang dapat dieksekusi. Ini menghasilkan pembuatan proses init. Ini adalah proses pertama yang dibuat. Proses init memiliki PID satu, dan merupakan induk super dari semua proses dalam sesi Linux. Jika Anda menganggap struktur proses Linux sebagai sebuah pohon maka init adalah simpul awal dari pohon tersebut.

Untuk mengonfirmasi bahwa init adalah proses pertama, Anda dapat menjalankan perintah pstree di kotak Linux Anda. Perintah ini menampilkan pohon proses untuk sesi Linux.

Berikut adalah contoh keluarannya :

init-+-NetworkManager-+-dhclient
     |                |-dnsmasq
     |                `-3*[{NetworkManager}]
     |-accounts-daemon---2*[{accounts-daemon}]
     |-acpid
     |-at-spi-bus-laun-+-dbus-daemon
     |                 `-3*[{at-spi-bus-laun}]
     |-at-spi2-registr---{at-spi2-registr}
     |-avahi-daemon---avahi-daemon
     |-bamfdaemon---3*[{bamfdaemon}]
     |-bluetoothd
     |-colord---{colord}
     |-console-kit-dae---64*[{console-kit-dae}]
     |-cron
     |-cups-browsed
     |-cupsd
     |-2*[dbus-daemon]
     |-dbus-launch
     |-dconf-service---2*[{dconf-service}]
     |-evince---3*[{evince}]
     |-evinced---{evinced}
     |-evolution-sourc---2*[{evolution-sourc}]
     |-firefox-+-plugin-containe---16*[{plugin-containe}]
     |         `-36*[{firefox}]
     |-gconfd-2
     |-gedit---3*[{gedit}]
     |-6*[getty]
     |-gnome-keyring-d---7*[{gnome-keyring-d}]
     |-gnome-terminal-+-bash
     |                |-bash-+-less
     |                |      `-pstree
     |                |-gnome-pty-helpe
     |                `-3*[{gnome-terminal}]
     |-gvfs-afc-volume---2*[{gvfs-afc-volume}]
     |-gvfs-gphoto2-vo---{gvfs-gphoto2-vo}
     |-gvfs-mtp-volume---{gvfs-mtp-volume}
     |-gvfs-udisks2-vo---{gvfs-udisks2-vo}
     |-gvfsd---{gvfsd}
     |-gvfsd-burn---2*[{gvfsd-burn}]
     |-gvfsd-fuse---4*[{gvfsd-fuse}]
     ...
     ...
     ...

Output mengkonfirmasi bahwa init berada di atas pohon proses. Juga, jika Anda mengamati teks yang dicetak tebal, Anda akan melihat relasi induk anak lengkap dari proses pstree. Baca lebih lanjut tentang pstree di artikel kami tentang tree dan pstree.

Sekarang, mari kembali ke pertanyaan (kita biarkan terbuka di bagian terakhir) tentang konsekuensi ketika proses induk terbunuh saat anak masih hidup. Nah dalam hal ini, anak tersebut jelas menjadi yatim piatu tetapi diadopsi oleh proses init. Jadi, proses init menjadi induk baru dari proses anak yang induknya dihentikan.

4. Siklus Hidup Proses

Di bagian ini, kita akan membahas siklus hidup dari proses Linux normal yang tercakup sebelum dimatikan dan dihapus dari tabel proses kernel.

• Seperti yang telah dibahas, proses baru dibuat melalui fork() dan jika executable baru akan dijalankan, maka keluarga fungsi exec() dipanggil setelah fork(). Segera setelah proses baru ini dibuat, proses tersebut akan dimasukkan ke dalam antrian proses yang siap dijalankan.
• Jika hanya fork() yang dipanggil maka kemungkinan besar proses baru berjalan dalam mode pengguna tetapi jika exec() dipanggil maka proses baru akan berjalan dalam mode kernel sampai ruang alamat proses baru dibuat untuknya.
• Saat proses sedang berjalan, proses dengan prioritas lebih tinggi dapat mendahuluinya melalui interupsi. Dalam hal ini, proses yang didahului kembali masuk ke antrian proses yang siap dijalankan. Proses ini diambil oleh penjadwal pada tahap selanjutnya.
• Sebuah proses dapat masuk ke mode kernel saat berjalan. Hal ini dimungkinkan ketika memerlukan akses beberapa sumber daya seperti file teks yang disimpan di hard disk. Karena operasi yang melibatkan akses ke perangkat keras mungkin memakan waktu, kemungkinan besar proses akan tertidur dan akan bangun hanya ketika data yang diminta tersedia. Ketika proses dibangkitkan, itu tidak berarti bahwa itu akan segera dieksekusi, itu akan kembali mengantri dan akan dipilih untuk dieksekusi oleh penjadwal pada waktu yang tepat.
• Sebuah proses dapat dimatikan melalui banyak cara. Itu dapat memanggil fungsi exit() untuk keluar atau dapat memproses sinyal Linux untuk keluar. Selain itu, beberapa sinyal tidak dapat ditangkap dan menyebabkan proses segera dihentikan.
• Ada berbagai jenis proses Linux. Setelah proses dimatikan, itu tidak sepenuhnya dihilangkan. Entri yang berisi beberapa informasi yang terkait dengannya disimpan dalam tabel alamat proses Kernel hingga proses induk secara eksplisit memanggil fungsi wait() atau waitpid() untuk mendapatkan status keluar dari proses anak. Sampai proses induk melakukan ini, proses yang dihentikan dikenal sebagai proses zombie.