Memahami Proses di Linux

Tutorial ini memberikan detail tentang proses apa, bagaimana mereka digunakan dan bagaimana mereka dapat dikelola di Linux.

Sebagai administrator sistem, Anda mungkin pernah berinteraksi dengan proses dalam berbagai cara.

Terkadang, Anda mungkin ingin menjalankan perintah untuk mengidentifikasi proses yang menghabiskan banyak sumber daya di host Anda.

Anda mungkin telah menerima panggilan dari pengguna yang menyatakan bahwa salah satu proses mereka macet dan Anda mungkin perlu mematikannya agar dapat terus bekerja.

Proses benar-benar berada di pusat sistem operasi Linux :dibuat oleh Kernel itu sendiri, proses tersebut mewakili operasi yang sedang berjalan yang saat ini terjadi di host Linux Anda.

Proses ada di mana-mana, mereka dapat berjalan di latar belakang atau Anda dapat memilih untuk menginisialisasinya sendiri untuk operasi kustom.

Anda dapat memilih untuk memulai mereka, untuk menginterupsi mereka, untuk melanjutkan mereka atau untuk menghentikan mereka.

Dalam tutorial hari ini, kita akan melihat lebih dekat pada proses, apa itu, dan bagaimana mereka digunakan pada sistem operasi kita.

Kami akan menemukan semua perintah yang terkait dengan proses, apa sinyalnya, dan bagaimana kami dapat menetapkan lebih banyak sumber daya komputasi ke proses yang ada.

Siap?

Yang Akan Anda Pelajari

Dengan membaca tutorial ini sampai akhir, Anda akan mempelajari konsep-konsep berikut

• Apa proses dan bagaimana mereka dibuat pada sistem Linux
• Bagaimana proses dapat diidentifikasi pada sistem Linux
• Apa latar belakang dan latar depan prosesnya
• Apa sinyal dan bagaimana mereka dapat digunakan untuk berinteraksi dengan proses
• Cara menggunakan pgrep serta pkill perintah secara efektif
• Cara menyesuaikan prioritas proses menggunakan bagus dan menyewa
• Cara melihat aktivitas proses secara real-time di Linux

Itu program yang cukup panjang, jadi tanpa basa-basi lagi, mari kita mulai dengan deskripsi singkat tentang apa itu proses.

Dasar-dasar Proses Linux

Singkatnya, proses menjalankan program di host Linux Anda yang melakukan operasi seperti menulis ke disk, menulis ke file, atau menjalankan server web misalnya.

Proses memiliki pemilik dan mereka diidentifikasi oleh ID proses (juga disebut PID )

Sebaliknya, program adalah baris atau kode atau baris instruksi mesin yang disimpan pada penyimpanan data persisten.

Mereka hanya bisa duduk di penyimpanan data Anda, atau mereka bisa dieksekusi, yaitu berjalan sebagai proses.

Untuk melakukan operasi yang ditugaskan padanya, proses membutuhkan sumber daya :waktu CPU , memori (seperti RAM atau ruang disk ), tetapi juga memori virtual seperti ruang tukar jika proses Anda menjadi terlalu rakus.

Jelas, proses dapat dimulai , berhenti , diinterupsi dan bahkan membunuh .

Sebelum mengeluarkan perintah apa pun, mari kita lihat bagaimana proses dibuat dan dikelola oleh kernel itu sendiri.

Inisialisasi Proses di Linux

Seperti yang telah kami nyatakan, proses dikelola oleh Kernel di Linux.

Namun, ada konsep inti yang perlu Anda pahami untuk mengetahui bagaimana Linux membuat proses.

Secara default, ketika Anda mem-boot sistem Linux, kernel Linux Anda dimuat ke dalam memori, itu diberikan sistem file virtual di RAM (juga disebut initramfs ) dan perintah awal dijalankan.

Salah satu dari perintah tersebut memulai proses pertama di Linux.

Secara historis, proses ini disebut proses init tetapi digantikan oleh proses inisialisasi systemd pada banyak distribusi Linux baru-baru ini.

Untuk membuktikannya, jalankan perintah berikut pada host Anda

$ ps -aux | head -n 2

Seperti yang Anda lihat, proses systemd memiliki PID 1.

Jika Anda mencetak semua proses pada sistem Anda, menggunakan tampilan pohon, Anda akan menemukan bahwa semua proses adalah anak-anak dari sistem.

$ pstree

Patut diperhatikan untuk menggarisbawahi fakta bahwa semua langkah inisialisasi tersebut (kecuali untuk peluncuran proses awal) dilakukan di ruang khusus yang disebut ruang kernel.

Ruang kernel adalah ruang yang disediakan untuk Kernel untuk menjalankan alat sistem penting dengan benar dan untuk memastikan bahwa seluruh host Anda berjalan dengan cara yang konsisten.

Di sisi lain, ruang pengguna dicadangkan untuk proses diluncurkan oleh pengguna dan dikelola oleh kernel itu sendiri.

Akibatnya, proses systemd adalah proses pertama yang diluncurkan di ruang pengguna.

Proses Pembuatan menggunakan Fork dan Exec

Saat Anda membuat dan menjalankan program di Linux, biasanya melibatkan dua langkah utama:fork dan jalankan .

Operasi garpu

Fork adalah operasi kloning, mengambil proses saat ini, juga disebut proses induk, dan mengkloningnya dalam proses baru dengan ID proses baru.

Saat melakukan forking, semuanya disalin dari proses induk :tumpukan , tumpukan , tetapi juga deskriptor file yang berarti input standar, output standar, dan kesalahan standar.

Artinya, jika proses induk saya menulis ke konsol shell saat ini, proses anak juga akan menulis ke konsol shell.

Eksekusi proses kloning juga akan dimulai pada instruksi yang sama dengan proses induk.

Jalankan operasi

Operasi eksekusi digunakan di Linux untuk mengganti gambar proses saat ini dengan gambar dari proses lain.

Pada diagram sebelumnya, kita melihat bahwa tumpukan proses induk berisi tiga instruksi yang tersisa.

Akibatnya, instruksi disalin ke proses baru tetapi tidak relevan dengan apa yang ingin kita jalankan.

Operasi exec akan menggantikan gambar proses (yaitu kumpulan instruksi yang perlu dieksekusi) dengan yang lain.

Jika Anda misalnya menjalankan perintah exec di terminal bash Anda, shell Anda akan berakhir segera setelah perintah selesai karena gambar proses Anda saat ini (penerjemah bash Anda) akan diganti dengan konteks perintah yang Anda coba luncurkan .

$ exec ls -l

Jika Anda melacak panggilan sistem yang dilakukan saat membuat proses, Anda akan menemukan bahwa perintah C pertama yang dipanggil adalah perintah eksekutif.

Membuat proses dari lingkungan shell

Saat Anda meluncurkan konsol shell, prinsip yang sama persis berlaku saat Anda meluncurkan perintah.

Konsol shell adalah proses yang menunggu input dari pengguna.

Ini juga meluncurkan penerjemah bash saat Anda menekan Enter dan menyediakan lingkungan untuk menjalankan perintah Anda.

Tetapi shell mengikuti langkah-langkah yang kami jelaskan sebelumnya.

Saat Anda menekan enter, shell bercabang ke proses anak yang akan bertanggung jawab untuk menjalankan perintah Anda. Shell akan menunggu dengan sabar sampai eksekusi proses anak selesai.

Di sisi lain, proses anak ditautkan ke deskriptor file yang sama dan mungkin berbagi variabel yang dideklarasikan pada lingkup global.

Proses anak mengeksekusi “exec ” untuk mengganti gambar proses saat ini (yang merupakan gambar proses shell) dalam gambar proses dari perintah yang Anda coba jalankan.

Proses anak pada akhirnya akan selesai dan akan mencetak hasilnya ke output standar yang diwarisi dari proses induk, dalam hal ini konsol shell itu sendiri.

Sekarang setelah Anda memiliki beberapa dasar tentang bagaimana proses dibuat di lingkungan Linux Anda, mari kita lihat beberapa detail tentang proses dan bagaimana mereka dapat diidentifikasi dengan mudah.

Mengidentifikasi proses yang berjalan di Linux

Cara termudah untuk mengidentifikasi proses yang berjalan di Linux adalah dengan menjalankan ps perintah.

$ ps

Secara default, perintah ps akan menampilkan daftar proses yang sedang berjalan yang dimiliki oleh pengguna saat ini.

Dalam hal ini, hanya dua proses yang berjalan untuk pengguna saya:penerjemah bash dan perintah ps Saya telah mengalaminya.

Bagian penting di sini adalah bahwa proses memiliki pemilik , sebagian besar waktu adalah pengguna yang menjalankannya terlebih dahulu.

Untuk mengilustrasikannya, mari kita lihat daftar sepuluh proses pertama di sistem operasi Linux Anda, dengan format tampilan yang berbeda.

$ ps -ef | head -n 10

Seperti yang Anda lihat di sini, sepuluh proses teratas dimiliki oleh pengguna “root “.

Informasi ini akan sangat penting saat berinteraksi dengan proses dengan sinyal.

Untuk menampilkan proses yang dimiliki dan dijalankan oleh pengguna yang terhubung saat ini, jalankan perintah berikut

$ ps u

Ada banyak pilihan yang berbeda untuk perintah ps, dan mereka dapat dilihat dengan menjalankan perintah manual.

$ man ps

Dari pengalaman, dua perintah terpenting untuk melihat proses yang berjalan adalah

ps aux

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

Itu sesuai dengan daftar proses bergaya BSD , dimana perintah berikut

ps -ef

UID  PID  PPID C STIME TTY  TIME CMD

Sesuai dengan daftar proses bergaya POSIX .

Keduanya mewakili proses yang sedang berjalan pada sistem, tetapi yang pertama memiliki opsi "u" untuk "berorientasi pengguna" yang membuatnya lebih mudah untuk membaca metrik proses.

Sekarang setelah Anda melihat proses apa dan bagaimana proses tersebut dapat dicantumkan, mari kita lihat proses latar belakang dan latar depan apa yang ada di host Anda.

Proses latar belakang dan latar depan

Definisi proses latar belakang dan latar depan cukup jelas.

Pekerjaan dan proses di shell saat ini

Proses latar belakang di Linux adalah proses yang berjalan di latar belakang, artinya tidak dikelola secara aktif oleh pengguna melalui shell misalnya.

Di sisi yang berlawanan, proses latar depan adalah proses yang dapat berinteraksi melalui masukan pengguna langsung.

Katakanlah misalnya Anda telah membuka terminal shell, dan Anda mengetikkan perintah berikut di konsol Anda.

$ sleep 10000

Seperti yang mungkin Anda perhatikan, terminal Anda akan hang hingga penghentian proses tidur. Akibatnya, proses tidak dijalankan di latar belakang, tetapi dijalankan di latar depan.

Saya mampu berinteraksi dengannya. Jika saya menekan Ctrl + Z, itu akan langsung mengirim sinyal berhenti ke proses misalnya.

Namun, ada cara untuk menjalankan proses di latar belakang.

Untuk menjalankan proses di latar belakang, cukup beri tanda “& ” tanda di akhir perintah Anda.

$ sleep 10000 &

Seperti yang Anda lihat, kontrol langsung diberikan kembali ke pengguna dan proses mulai dijalankan di latar belakang

Untuk melihat proses Anda berjalan, dalam konteks shell saat ini, Anda dapat menjalankan perintah jobs

$ jobs

Pekerjaan adalah daftar proses yang dimulai dalam konteks shell saat ini dan yang mungkin masih berjalan di latar belakang.

Seperti yang Anda lihat pada contoh di atas, saya memiliki dua proses yang sedang berjalan di latar belakang.

Kolom yang berbeda dari kiri ke kanan mewakili ID pekerjaan, status proses (yang akan Anda temukan di bagian berikutnya), dan perintah dijalankan.

Menggunakan perintah bg dan fg

Untuk berinteraksi dengan pekerjaan, Anda memiliki dua perintah yang tersedia:bg dan fg .

Perintah bg digunakan di Linux untuk mengirim proses ke latar belakang dan sintaksnya adalah sebagai berikut

$ bg %<job_id>

Demikian pula, untuk mengirim proses ke latar depan, Anda dapat menggunakan fg dengan cara yang sama

$ fg %<job_id>

Jika kita kembali ke daftar pekerjaan dari contoh sebelumnya, jika saya ingin membawa pekerjaan 3 ke latar depan, artinya ke jendela shell saat ini, saya akan menjalankan perintah berikut

$ fg %3

Dengan mengeluarkan perintah Ctrl + Z, saya dapat menghentikan prosesnya. Saya dapat menautkannya dengan perintah bg untuk mengirimkannya ke latar belakang.

Sekarang setelah Anda memiliki gagasan yang lebih baik tentang proses latar belakang dan latar depan, mari kita lihat bagaimana Anda dapat berinteraksi dengan proses menggunakan sinyal.

Berinteraksi dengan proses menggunakan sinyal

Di Linux, sinyal adalah bentuk komunikasi antarproses (juga disebut IPC ) yang membuat dan mengirimkan pemberitahuan asinkron ke proses yang sedang berjalan tentang terjadinya peristiwa tertentu.

Sinyal sering digunakan untuk mengirim pembunuhan atau perintah penghentian ke proses untuk mematikannya (juga disebut sinyal mematikan).

Untuk mengirim sinyal ke suatu proses, Anda harus menggunakan tombol kill perintah.

$ kill -<signal number> <pid>|<process_name>

Misalnya, untuk memaksa proses HTTPD (PID =123) berhenti (tanpa shutdown bersih), Anda akan menjalankan perintah berikut

$ kill -9 123

Kategori sinyal dijelaskan

Seperti yang dijelaskan, ada banyak sinyal yang dapat dikirim seseorang untuk memberi tahu proses tertentu.

Berikut adalah daftar yang paling umum digunakan :

• MASUK :kependekan dari signal interrupt adalah sinyal yang digunakan untuk menginterupsi suatu proses yang sedang berjalan. Ini juga merupakan sinyal yang dikirim saat pengguna menekan Ctrl + C pada terminal;
• SIGHUP :kependekan dari sinyal hangup adalah sinyal yang dikirim oleh terminal Anda saat terminal ditutup. Sama halnya dengan SIGINT, proses berakhir;
• SIGKILL :sinyal yang digunakan untuk memaksa suatu proses berhenti apakah itu dapat dihentikan dengan anggun atau tidak. Sinyal ini tidak dapat diabaikan kecuali untuk proses init (atau sistem pada distribusi terbaru);

• SIGQUIT :sinyal spesifik yang dikirim saat pengguna ingin keluar atau keluar dari proses saat ini. Itu dapat dipanggil dengan menekan Ctrl + D dan sering digunakan di shell terminal atau di sesi SSH;
• SIGUSR1, SIGUSR2 :sinyal tersebut digunakan murni untuk tujuan komunikasi dan dapat digunakan dalam program untuk menerapkan penangan khusus;
• SIGSTOP :menginstruksikan proses untuk menghentikan eksekusinya tanpa menghentikan proses. Proses tersebut kemudian menunggu untuk dilanjutkan atau dihentikan sama sekali;
• SIGCONT :jika proses ditandai sebagai berhenti, proses akan menginstruksikan untuk memulai eksekusinya lagi.

Untuk melihat daftar lengkap semua sinyal yang tersedia, Anda dapat menjalankan perintah berikut

$ kill -l

 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

Sinyal dan Status Proses

Sekarang setelah Anda mengetahui bahwa proses dapat diinterupsi, dihentikan, atau dihentikan, sekarang saatnya Anda mempelajari status proses.

Proses memiliki banyak status yang berbeda, dapat berupa :

• Berlari :proses yang berjalan adalah proses yang menggunakan beberapa daya komputasi (seperti waktu CPU) pada waktu saat ini. Sebuah proses juga bisa disebut “runnable” jika semua kondisi yang berjalan terpenuhi, dan menunggu beberapa waktu CPU oleh penjadwal CPU.
• Berhenti :sinyal dihentikan ditautkan ke sinyal SIGSTOP atau ke pintasan keyboard Ctrl + Z. Eksekusi proses ditangguhkan dan menunggu SIGCONT atau SIGKILL.
• Tidur :proses tidur adalah proses yang menunggu beberapa peristiwa atau sumber daya (seperti disk) tersedia.

Berikut adalah diagram yang mewakili status proses berbeda yang terkait dengan sinyal yang mungkin Anda kirimkan kepada mereka.

Sekarang setelah Anda mengetahui lebih banyak tentang status proses, mari kita lihat perintah pgrep dan pkill.

Memanipulasi proses dengan pgrep dan pkill

Di Linux, sudah banyak yang bisa dilakukan hanya dengan menggunakan perintah ps.

Anda dapat mempersempit pencarian Anda ke satu proses tertentu, dan Anda dapat menggunakan PID untuk menghentikannya sepenuhnya.

Namun, ada dua perintah yang dirancang agar perintah Anda menjadi lebih pendek:pgrep dan pkill

Menggunakan perintah pgrep

pgrep perintah adalah jalan pintas untuk menggunakan perintah ps yang disalurkan dengan perintah grep.

Perintah pgrep akan mencari semua kejadian untuk proses tertentu menggunakan nama atau pola yang ditentukan.

Sintaks dari perintah pgrep adalah sebagai berikut

$ pgrep <options> <pattern>

Misalnya, jika Anda mencari semua proses bernama "bash" di host Anda, Anda akan menjalankan perintah berikut

$ pgrep bash

Perintah pgrep tidak terbatas pada proses yang dimiliki oleh pengguna saat ini secara default.

Jika pengguna lain menjalankan perintah bash, itu akan muncul di output dari perintah pgrep.

Dimungkinkan juga untuk mencari proses menggunakan karakter globbing.

Menggunakan perintah pkill

Di sisi lain, perintah pkill juga merupakan jalan pintas untuk perintah ps yang digunakan dengan perintah kill.

Perintah pkill digunakan untuk mengirim sinyal ke proses berdasarkan ID atau namanya.

Sintaks dari perintah pkill adalah sebagai berikut

$ pkill <options> <pattern>

Misalnya, jika Anda ingin mematikan semua jendela Firefox di host Anda, jalankan perintah berikut

$ pkill firefox

Sama halnya dengan perintah pgrep, Anda memiliki opsi untuk mempersempit hasil Anda dengan menentukan pengguna dengan opsi -u.

Untuk mematikan semua proses yang dimulai dengan "api" dan dimiliki oleh pengguna dan root saat ini, Anda dapat menjalankan perintah berikut

$ pkill user,root fire*

Jika Anda tidak memiliki hak untuk menghentikan proses, Anda akan mendapatkan pesan kesalahan izin ditolak ke output standar Anda.

Anda juga memiliki opsi untuk mengirim sinyal tertentu dengan menentukan nomor sinyal di perintah pkill

Misalnya, untuk menghentikan Firefox dengan sinyal SIGSTOP, Anda akan menjalankan perintah berikut

$ pkill -19 firefox

Menyesuaikan prioritas proses menggunakan nice dan renice

Di Linux, tidak semua proses diberikan prioritas yang sama dalam hal waktu CPU.

Beberapa proses, seperti proses yang sangat penting yang dijalankan oleh root, diberi prioritas lebih tinggi agar sistem operasi dapat mengerjakan tugas yang benar-benar penting bagi sistem.

Prioritas proses di Linux disebut tingkat yang bagus.

Level bagus adalah skala prioritas dari -20 hingga 19.

Semakin rendah Anda pada skala kebaikan, semakin tinggi prioritasnya.

Demikian pula, semakin tinggi Anda dalam skala kebaikan, semakin rendah prioritas Anda.

Untuk mengingatnya, Anda dapat mengingat fakta bahwa “semakin baik Anda, semakin Anda bersedia berbagi sumber daya dengan orang lain”.

Untuk memulai program atau proses tertentu dengan level yang bagus, Anda akan menjalankan perintah berikut

$ nice -n <level> <command>

Misalnya, untuk menjalankan perintah tar dengan level tar khusus, Anda akan menjalankan perintah berikut

$ nice -n 19 tar -cvf test.tar file

Demikian pula, Anda dapat menggunakan perintah renice untuk menyetel level bagus dari proses yang berjalan ke nilai tertentu.

$ renice -n <priority> <pid>

Misalnya, jika saya memiliki proses yang berjalan dengan PID 123, saya dapat menggunakan perintah renice untuk menetapkan prioritasnya ke nilai yang diberikan.

$ renice -n 18 123

Kebaikan dan izin

Jika Anda bukan anggota grup sudo (atau anggota grup roda pada distribusi berbasis Red Hat), ada beberapa batasan dalam hal apa yang Anda bisa dengan perintah Nice.

Untuk mengilustrasikannya, coba jalankan perintah berikut sebagai pengguna non-sudo

$ nice -n -1 tar -cvf test.tar file

nice: cannot set niceness: Permission denied

Dalam hal kebaikan, ada satu aturan yang perlu Anda ketahui :

Sebagai pengguna non-root (atau sudo), Anda tidak akan dapat menyetel level Nice lebih rendah dari level default yang ditetapkan (yaitu nol), dan Anda tidak akan dapat mengubah proses yang sedang berjalan ke tingkat yang lebih rendah dari yang sekarang.

Untuk mengilustrasikan poin terakhir, luncurkan perintah sleep di latar belakang dengan nilai bagus 2.

$ nice -n 2 sleep 10000 &

Selanjutnya, identifikasi ID proses dari proses yang baru saja Anda buat.

Sekarang, coba setel tingkat proses yang bagus ke nilai yang lebih rendah dari yang Anda tentukan sejak awal.

$ renice -n 1 8363

Seperti yang mungkin Anda perhatikan, Anda tidak akan dapat menyetel tingkat kebaikan ke 1, tetapi hanya ke nilai yang lebih tinggi dari yang Anda tentukan.

Sekarang jika Anda memilih untuk menjalankan perintah sebagai sudo, Anda akan dapat mengatur level Nice ke nilai yang lebih rendah.

Sekarang setelah Anda memiliki gagasan yang jelas tentang perintah Nice dan renice, mari kita lihat bagaimana Anda dapat memantau proses Anda secara real time di Linux.

Memantau proses di Linux menggunakan top dan htop

Dalam artikel sebelumnya, kita telah membahas bagaimana membangun pipa pemantauan lengkap untuk memantau proses Linux secara real time.

Menggunakan top di Linux

Top adalah perintah interaktif yang dapat dijalankan oleh setiap pengguna untuk memiliki daftar lengkap dan berurutan dari semua proses yang berjalan di host Linux.

Untuk menjalankan top, cukup jalankan tanpa argumen apa pun.

Top akan berjalan dalam mode interaktif.

$ top

Jika Anda ingin menjalankan top untuk jumlah iterasi khusus, jalankan perintah berikut

$ top -n <number>

Perintah top pertama-tama akan menampilkan statistik rekap tentang sistem Anda di bagian atas, misalnya jumlah tugas yang dijalankan, persentase CPU yang digunakan atau konsumsi memori.

Tepat di bawahnya, Anda memiliki akses ke daftar langsung semua proses yang berjalan atau tidur di host Anda.

Tampilan ini akan disegarkan setiap tiga detik, tetapi Anda jelas dapat mengubah parameter ini.

Untuk meningkatkan kecepatan refresh di perintah atas, tekan perintah “d” dan pilih kecepatan refresh baru

Demikian pula, Anda dapat mengubah nilai bagus dari proses yang berjalan secara langsung dengan menekan tombol “r” pada keyboard Anda.

Aturan izin yang sama berlaku jika Anda ingin mengubah proses ke nilai yang lebih rendah dari yang sudah ditetapkan.

Akibatnya, Anda mungkin perlu menjalankan perintah sebagai sudo.

Menggunakan htop di Linux

Atau, jika Anda mencari cara yang lebih baik untuk memvisualisasikan proses pada host Linux Anda, Anda dapat menggunakan perintah htop.

Secara default, perintah htop tidak tersedia di sebagian besar distribusi, jadi Anda perlu menginstalnya dengan petunjuk berikut.

$ sudo apt-get update
$ sudo apt-get install htop

Jika Anda menjalankan distribusi berbasis Red Hat, jalankan perintah berikut.

$ sudo yum -y install epel-release
$ sudo yum -y update
$ sudo yum -y install htop

Terakhir, untuk menjalankan perintah htop, jalankan saja tanpa argumen.

$ htop

Seperti yang Anda lihat, keluarannya sangat mirip kecuali ia menampilkan informasi dalam keluaran yang lebih ramah manusia.

Kesimpulan

Dalam tutorial ini, Anda mempelajari banyak konsep tentang proses:bagaimana proses itu dibuat, bagaimana mereka dapat dikelola, dan bagaimana mereka dapat dipantau secara efektif.

Jika Anda mencari lebih banyak tutorial terkait administrasi sistem Linux, kami memiliki bagian lengkap yang didedikasikan untuk itu di situs web, jadi pastikan untuk memeriksanya.