proses pada UNIX

Yang dimaksud dengan proses pada UNIX adalah program
yang sedang berjalan di dalam sistem, misalnya shell,
utilitas, atau aplikasi lainnya. Masukan dari proses dapat
berasal dari keyboard, file atau program lain. Keluaran dari
proses dapat ditampilkan ke layar terminal, file atau
program lain. Sebagian besar utilitas UNIX dirancang untuk
bekerja dalam kombinasi masukan dan keluaran seperti ini.
Pada artikel ini akan dijelaskan tentang konsep proses,
hubungan antar proses dan fasilitas yang berhubungan dengan
proses di dalam sistem UNIX. Pembahasan akan mencakup
mengenai:

- proses masukan dan keluaran
- pengalihan masukan dan keluaran
- pipa dan hubungannya dengan masukan dan keluaran
- proses latar depan dan latar belakang
- menghentikan proses
- menjadualkan proses


4.1 PROSES MASUKAN DAN KELUARAN

Sebuah program yang dijalankan di dalam sistem UNIX
biasanya akan membutuh beberapa masukan. Disamping itu
pula program biasanya menghasilkan suatu keluaran, baik itu
keluaran hasil maupun keluaran kesalahan. Keperluan-
keperluan tersebut ditangani oleh UNIX dengan menggunakan:

o Masukan standar
masukan standar merupakan sumber data dari program
dan sistem akan memberikan datanya pada saat proses
berjalan. Default masukan standar bagi program adalah
keyboard terminal. Bilangan deskriptor file untuk
masukan standar adalah 0.

o Keluaran standar
keluaran standar merupakan wadah dimana program dapat
menuliskan hasil eksekusi yang telah dijalankan.
Default keluaran standar bagi program adalah layar
terminal. Bilangan deskriptor file untuk keluaran
standar adalah 1.

o Keluaran kesalahan standar
keluaran kesalahan standar merupakan wadah dimana
program dapat menuliskan pesan kesalahan atas
eksekusi yang telah dijalankan. Default keluaran
kesalahan standar bagi program adalah layar terminal.
Bilangan deskriptor file untuk keluaran kesalahan
standar adalah 2.
Hal ini dapat digambarkan sebagai berikut:

............
. . |\
. --------+ \
. keluaran 1 > LAYAR TERMINAL
. --------+ /
. . |/
. |\ .
--------+ \ .
KEYBOARD masukan 0 > .
--------+ / .
. |/ .
. . |\
. --------+ \
. kesalahan 2> LAYAR TERMINAL
. --------+ /
. . |/
............


Gambar 4.1 Proses masukan dan keluaran


Kebanyakan program yang tersedia dalam UNIX mengambil
masukan dari masukan standar dan menuliskan keluaran ke
keluaran standar. Program seperti ini biasa disebut filter
Program yang menggunakan nama file sebagai
salah satu parameter dari perintahnya, sesungguhnya mengubah
masukan standarnya dari keyboard ke file, sehingga file
menjadi masukan bagi program. Sebagai contoh, misalnya kita
memiliki sebuah file bernama peserta yang berisi nama-nama.
File tersebut akan diurutkan berdasarkan nama dengan urut
kecil ke besar, maka cara yang dilakukan adalah sebagai
berikut:

$ sort peserta
arif budiman
bagus pribadi
denny yerianto
fanny angela
ferry sihombing
irmawati
$

Perintah sort mengasumsikan bahwa kita ingin mengurut
isi file peserta. Jika perintah sort dilakukan tanpa
memberikan nama file yang akan diurut sebagai argumen, maka
program mengharapkan masukan dari masukan standar yaitu
keyboard. Untuk itu maka kita dapat memasukkan nama-nama
yang akan diurut satu persatu sebagai masukan melalui
keyboard. Untuk mengakhiri masukan, ketikkan karakter end-
of-file, yaitu Kontrol-D pada awal baris, selanjutnya
perintah sort akan segera mengurut masukan.

$ sort
denny yerianto
fanny angela (masukan via keyboard)
bagus pribadi
arif budiman
irmawati
ferry sihombing
^D (akhiri masukan)
arif budiman (mulai proses urut)
bagus pribadi
denny yerianto
fanny angela
ferry sihombing
irmawati
$

Karena nama file tidak disebutkan pada perintah sort di
atas maka masukan standar perintah tersebut diambil dari
keyboard. Detil perintah sort akan dijelaskan pada bab
selanjutnya.

4.1.1 Pengalihan Keluaran

Dalam sistem UNIX, secara normal keluaran dari sebuah
perintah dikirim ke keluaran standar, yaitu layar terminal.
Namun keluaran tersebut secara mudah dapat dialihkan ke file
atau program lain. Kemampuan inilah yang disebut sebagai
pengalihan keluaran atau output redirection.
Jika karakter '>' diikuti nama file ditambahkan pada
akhir perintah UNIX yang menampilkan keluaran ke keluaran
standar, maka keluaran dari perintah tersebut akan dialihkan
ke file yang disebutkan dan tidak ditampilkan ke layar
terminal. Perhatikan ilustrasi berikut ini:


............
. . |\
. --------+ \
. keluaran 1 > FILE
. --------+ /
. . |/
. |\ .
--------+ \ .
KEYBOARD masukan 0 > .
--------+ / .
. |/ .
. . |\
. --------+ \
. kesalahan 2> LAYAR TERMINAL
. --------+ /
. . |/
............

Gambar 4.2 Proses pengalihan keluaran

Baris perintah berikut ini akan menyebabkan keluaran
perintah who dialihkan dari layar terminal ke file.

$ who
heru tty05 Oct 23 07:30
root tty01 Oct 23 07:28
denny tty02 Oct 23 07:28
ucrit tty03 Oct 23 07:29
chaerind tty04 Oct 23 07:30
$ who > peserta
$

Pada perintah who kedua tidak terlihat keluaran pada
layar terminal. Hal ini disebabkan keluarannya telah
dialihkan ke file peserta. Kita dapat memeriksa isi file
peserta dengan perintah cat sebagai berikut:

$ cat peserta
heru tty05 Oct 23 07:30
root tty01 Oct 23 07:28
denny tty02 Oct 23 07:28
ucrit tty03 Oct 23 07:29
chaerind tty04 Oct 23 07:30
$

Contoh lain dari pengalihan keluaran adalah penyimpanan
tanggal dan waktu ke dalam file waktu sebagai berikut:

$ date
Fri Oct 23 07:28:32 PDT 1992
$ date > waktu
$ cat waktu
Fri Oct 23 07:28:32 PDT 1992
$

Perintah echo menuliskan keluaran ke keluaran standar,
sehingga dapat dialihkan sebagai berikut:

$ echo baris satu > berkas
$ cat berkas
baris satu
$

Jika keluaran sebuah perintah dialihkan ke sebuah file
yang sebelumnya telah berisi data, maka data sebelumnya akan
hilang dan diganti dengan data yang baru. Perhatikan contoh
berikut ini.

$ echo baris satu > berkas
$ cat berkas
baris satu
$ echo baris dua > berkas
$ cat berkas
baris dua
$
Isi dari file berkas (baris satu) hilang tertimpa data
baru ketika perintah echo kedua dieksekusi.
Jika diinginkan data sebelumnya tidak hilang dan data
baru ditambahkan di bawah data lama, maka gunakanlah
karakter '>>' sebagai pengganti karakter '>'.

$ echo baris satu > berkas
$ cat berkas
baris satu
$ echo baris dua >> berkas (append)
$ cat berkas
baris satu (tidak hilang !)
baris dua
$

4.1.2 Perintah cat dan Hubungannya dengan Proses

Berbeda dengan uraian mengenai perintah cat pada bab
sebelumnya, kali ini akan diuraikan kemampuan perintah cat
dan hubungannya dengan proses.
Seperti pada sebagaian besar perintah lainnya pada
UNIX, default masukan dan keluaran perintah cat adalah
masukan standar dan keluaran standar. Artinya jika tidak ada
nama file yang dikirim sebagai parameter dari perintah cat,
maka masukan diambil dari keyboard terminal.

$ cat
baris satu
baris satu
baris dua
baris dua
baris tiga
baris tiga
^D
$

Perintah cat diatas menerima masukan dari masukan
standar, yaitu keyboard terminal dan langsung ditampilkan
melalui keluaran standar, yaitu layar terminal.
Agar masukan yang kita ketik dapat disimpan di dalam
file, maka keluaran dari perintah cat harus dialihkan ke
file tertentu.

$ cat > sampah
baris satu
baris dua
baris tiga
^D
$ cat sampah
baris satu
baris dua
baris tiga
$


Dengan menggunakan karakter pengalihan '>>', kita dapat
menambahkan isi suatu file ke file lainnya.

$ cat berkas1
berkas1 baris 1
berkas1 baris 2
$ cat berkas2
berkas2 baris 3
berkas2 baris 4
berkas2 baris 5
$ cat berkas2 >> berkas1
$ cat berkas1
berkas1 baris 1
berkas1 baris 2
berkas2 baris 3
berkas2 baris 4
berkas2 baris 5
$

Jumlah file yang akan ditambahkan ke dalam suatu file
dapat lebih dari satu dan akan disusun berurutan.

$ cat berkas1
berkas1 baris 1
berkas1 baris 2
$ cat berkas2
berkas2 baris 3
berkas2 baris 4
berkas2 baris 5
$ cat berkas3
berkas3 baris 6
berkas3 baris 7
berkas3 baris 8
$ cat berkas2 berkas3 >> berkas1
$ cat berkas1
berkas1 baris 1
berkas1 baris 2
berkas2 baris 3
berkas2 baris 4
berkas2 baris 5
berkas3 baris 6
berkas3 baris 7
berkas3 baris 8
$

Penyusunan file yang dilarang pada perintah cat adalah
sebagai berikut:

cat file1 file2 > file2

karena proses yang terjadi tidak akan berjalan dengan
baik dan sulit diprediksi hasilnya. Untuk mengerjakan proses
di atas terpaksa harus digunakan file sementara.


$ cat file1 file2 > temp
$ mv temp file2
$

4.1.3 Pengalihan Masukan

Jika keluaran dari sebuah perintah dapat dialihkan,
maka masukan dari sebuah perintah pun dapat dialihkan,
misalnya mengalihkan masukan dari keyboard terminal menjadi
masukan dari file. Untuk mengalihkan masukan ke dalam sebuah
perintah dapat digunakan karakter '<' diikuti dengan nama
file masukan. Perhatikan ilustrasi berikut ini:


............
. . |\
. --------+ \
. keluaran 1 > LAYAR TERMINAL
. --------+ /
< . . |/
. |\ .
--------+ \ .
FILE masukan 0 > .
--------+ / .
. |/ .
. . |\
. --------+ \
. kesalahan 2> LAYAR TERMINAL
. --------+ /
. . |/
............

Gambar 4.3 Proses pengalihan masukan


Sebagai contoh, untuk menghitung jumlah baris di dalam
file peserta digunakan perintah wc -l sebagai berikut:

$ wc -l peserta
6 peserta
$

Atau kita juga dapat menghitung jumlah baris file
dengan mengalihkan masukan dari perintah wc.

$ wc -l < peserta
6
$

Perhatikan bahwa ada perbedaan keluaran yang dihasilkan
dari dua bentuk pemanggilan perintah wc di atas. Pada
perintah wc pertama nama file disertakan pada keluaran,
sedangkan pada perintah wc kedua nama file tidak disertakan
pada keluaran. Perbedaan ini disebabkan karena pada perintah
wc pertama, wc mengenal nama file yang dibaca. Pada perintah
wc kedua, wc hanya mengenal bahwa ia mengambil data dari
masukan standar dimana masukan standar menerima pengalihan
dari file.
Beberapa perintah UNIX tidak memiliki parameter yang
berupa nama file yang berisi data yang akan diolah. Masukan
hanya diterima melalui masukan standar atau melalui
pengalihan masukan. Sebagai contoh, perintah untuk melakukan
translasi karakter, yaitu perintah tr.

$ tr '[a-z]' '[A-Z]' (masukan standar)
chaerinda
CHAERINDA
denny yerianto
DENNY YERIANTO
^D
$ cat peserta
arif budiman
bagus pribadi
denny yerianto
fanny angela
ferry sihombing
irmawati
$ tr '[a-z]' '[A-Z]' < peserta (hanya via pengalihan)
ARIF BUDIMAN
BAGUS PRIBADI
DENNY YERIANTO
FANNY ANGELA
FERRY SIHOMBING
IRMAWATI
$

4.1.4 Pengalihan Masukan dan Keluaran

Sering terjadi bahwa kita tidak sekedar mengalihkan
masukan saja atau mengalihkan keluaran saja. Namun
mengalihkan masukan dan keluaran bersama-sama. Untuk
jelasnya marilah kita lihat kasus berikut ini.

$ cat peserta
arif budiman
bagus pribadi
denny yerianto
fanny angela
ferry sihombing
irmawati
$ tr '[a-z]' '[A-Z]' < peserta (hanya via pengalihan)
ARIF BUDIMAN
BAGUS PRIBADI
DENNY YERIANTO
FANNY ANGELA
FERRY SIHOMBING
IRMAWATI
$


$ cat peserta
arif budiman
bagus pribadi
denny yerianto
fanny angela
ferry sihombing
irmawati
$

Hasil perintah tr tidak tersimpan di dalam file peserta
dan file aslinya tidak berubah sama sekali. Untuk
mendapatkan hasil dari perintah tr maka kita harus melakukan
pengalihan masukan dan keluar bersama-sama.

$ tr '[a-z]' '[A-Z]' < peserta > uppercase
$ cat uppercase
ARIF BUDIMAN
BAGUS PRIBADI
DENNY YERIANTO
FANNY ANGELA
FERRY SIHOMBING
IRMAWATI
$

Jika diinginkan file aslinya berubah, kita perlu
melakukan:

$ mv uppercase peserta
$ cat peserta
ARIF BUDIMAN
BAGUS PRIBADI
DENNY YERIANTO
FANNY ANGELA
FERRY SIHOMBING
IRMAWATI
$


4.1.5 Pengalihan Keluaran Kesalahan Standar

Ada beberapa keluaran program yang ditampilkan di layar
terminal tetapi tidak dapat dialih dengan menggunakan cara-
cara di atas. Keluaran tersebut adalah keluaran kesalahan
standar.

$ cat peserta takada > gabung
cat: cannot open takada (file takada tidak ada)
$ cat gabung
ARIF BUDIMAN
BAGUS PRIBADI
DENNY YERIANTO
FANNY ANGELA
FERRY SIHOMBING
IRMAWATI
$

Perhatikan bahwa pesan kesalahan cat: cannot open
takada tidak terekam di dalam file gabung. Permasalahannya
kini adalah bagaimana agar pesan kesalahan tersebut terekam
di dalam file gabung dan tidak ditampilkan di layar
terminal. Untuk keperluan tersebut, maka kita perlu
mengalihkan keluaran kesalahan standar. Perhatikan contoh
ilustrasi pengalihan sebagai berikut:


............
. . |\
. -------------+ \
. keluaran 1 > FILE
. -------------+ /
. . ^ |/
. |\ . / \
--------+ \ . /_2_\
KEYBOARD masukan 0 > . | |
--------+ / . | |
. |/ . | |
. . | |
. ---------+ |
. kesalahan |
. -----------+
. . 2&1
............

Gambar 4.4 Proses pengalihan keluaran kesalahan standar


Pada proses pengalihan keluaran kesalahan standar harus
memperhatikan deskriptor file. Perhatikan tabel berikut ini.


------------------------------------------------------
Nomor Deskriptor file Fungsi
------------------------------------------------------
0 Masukan standar
1 Keluaran standar
2 Keluaran kesalahan standar
------------------------------------------------------

Tabel 4.1. Deskriptor file


Untuk mengalihkan keluaran kesalahan standar ke dalam
sebuah file digunakan deskriptor file 2 dengan notasi
sebagai berikut

2> namafile

Perhatikan bahwa konstruksi penulisan tidak mengijinkan
penggunaan spasi diantara angka 2 dan karakter '>'.
Berikut ini contoh dimana pesan kesalahan dialihkan ke dalam
sebuah file.

$ cat peserta takada 2> salah
ARIF BUDIMAN
BAGUS PRIBADI
DENNY YERIANTO
FANNY ANGELA
FERRY SIHOMBING
IRMAWATI
$ cat salah
cat: cannot open takada (file takada tidak ada)
$

Untuk menggabungkan keluaran standar atau keluaran
kesalahan ke file yang mengikuti digunakan notasi berikut:

perintah >&

Berikut ini contoh untuk menggabungkan keluaran
kesalahan standar (2) ke keluaran standar (1).

$ cat peserta takada > output 2>&1
$ cat salah
ARIF BUDIMAN
BAGUS PRIBADI
DENNY YERIANTO
FANNY ANGELA
FERRY SIHOMBING
IRMAWATI
cat: cannot open takada (kesalahan tergabung)
$


4.2 PEMIPAAN

Pada contoh-contoh diatas bila kita ingin menggunakan
keluaran dari suatu program menjadi masukan dari program
lain, maka kita harus menggunakan file sementara, untuk
aliran data. Berkas sementara tersebut akan dihapus jika
telah selesai digunakan.

$ who > pemakai
$ wc -l < pemakai
5
$

Cara lain yang lebih efisien adalah dengan menggunakan
fasilitas pemipaan dari UNIX. Pemipaan merupakan mekanisme
untuk menggabungkan keluaran dari suatu program menjadi
masukan dari program lain. Untuk melakukan pemipaan
digunakan karakter pipa '|' yang akan menginstruksikan
shell untuk membangun hubungan keluaran masukan antara dua
program. Hal ini dapat diilustrasikan sebagai berikut:


............
. . |\
. --------+ \
. keluaran 1 > LAYAR
| . --------+ / TERMINAL
............ . . |/
. . |\ . |\ .
. --------+ \---------+ \ .
. keluaran 1 >masukan 0 > .
. --------+ /---------+ / .
KEY . . |/ . |/ .
BOARD. |\ . . . |\
--------+ \ . . --------+ \
masukan 0 > . . kesalahan 2> LAYAR
--------+ / . . --------+ / TERMINAL
. |/ . . . |/
. . . . |\
. -----------------. .-+ \
. kesalahan . . 2 > LAYAR
. -----------------. .-+ / TERMINAL
. . . . |/
............ ............

Gambar 4.5 Proses pemipaan


Contoh di atas dapat diubah dengan menggunakan pipa
sebagai berikut:

$ who | wc -l
5
$

Program yang membaca masukan dari masukan standar dapat
di alihkan masukannya dari program lain dengan menggunakan
pipa. Konvensi ini berlaku untuk hampir semua program
standar dalam sistem UNIX.
Pemipaan dapat dilakukan secara berurutan untuk lebih
dari dua program. Program akan berjalan sesuai urutan dalam
pipa.

$ who | sort | wc -l
5
$

Sistem UNIX hanya memproses pemipaan bagi keluaran
standar dari suatu program dan tidak memproses pemipaan bagi
keluaran kesalahan standar sehingga kesalahan suatu program
pada saat melakukan pemipaan tetap ditampilkan.

$ ls file1 file2 file3 file4 | wc -l > test
file2 not found
$ cat test
3
$

Dengan sedikit trik kita dapat mengatasi hal ini, yaitu
dengan pengalihan kesalahan standar ke keluaran standar
sebagai berikut:

$ ls file1 file2 file3 file4 2>&1 | wc -l > test
$ cat test
file2 not found
3
$

Sistem UNIX juga menyediakan fasilitas untuk
mencabangkan keluaran dari hasil eksekusi program, yaitu
dengan menggunakan perintah tee. Hal ini dapat
diilustrasikan sebagai berikut:


FILE
^
/ \
............ /_1_\
. . | | |\
. --------+ +--+ \
. keluaran 1 > LAYAR TERMINAL
. -------------+ /
. . |/
. |\ .
--------+ \ .
KEYBOARD masukan 0 > .
--------+ / .
. |/ .
. . |\
. --------+ \
. kesalahan 2> LAYAR TERMINAL
. --------+ /
. . |/
............


Gambar 4.6 Proses tee


Perhatikan contoh berikut ini:

$ who | tee pemakai | wc -l
5
$ cat pemakai
heru tty05 Oct 23 07:30
root tty01 Oct 23 07:28
denny tty02 Oct 23 07:28
ucrit tty03 Oct 23 07:29
chaerind tty04 Oct 23 07:30
$

Dengan perintah tee, hasil keluaran dari perintah who
yang diterima melalui pipa, dicabang dua (T) ke layar
terminal dan file.


4.3 PROSES LATAR DEPAN DAN LATAR BELAKANG

UNIX merupakan sebuah sistem multitasking dan
multiuser. Multitasking berarti lebih dari satu program yang
dapat berjalan pada waktu yang bersamaan. Sedangkan
multiuser berarti bahwa lebih dari satu pemakai yang dapat
login dan menjalankan program pada waktu yang bersamaan.
Terdapat sekurangnya satu proses atau program yang berjalan
pada sistem UNIX untuk setiap pemakai yang login.
Konsep pemikiran yang mendasari pemikiran multitasking
dan multiuser adalah dikarenakan komputer sangat cepat
sehingga dapat menjalankan sebuah proses untuk sesaat,
beralih ke proses lain dan menjalankan untuk sesaat serta
kemudian beralih kembali ke proses semula. Dengan demikian
seolah-olah keduanya berjalan pada waktu yang bersamaan.
UNIX menentukan program yang berjalan dan mengatur peralihan
bolak-balik antar mereka.
Setiap proses yang dijalankan oleh UNIX memiliki
sebuah prioritas tertentu. Jika terdapat beberapa proses
yang siap untuk dijalankan, maka UNIX akan menjalankan
proses yang memiliki prioritas tertinggi.
Ada dua jenis proses yang terjadi di dalam sistem UNIX,
yaitu proses yang berhubungan langsung dengan terminal
pemakai disebut proses latar depan (foreground processes)
dan proses yang berjalan yang tidak berhubungan dengan
terminal pemakai disebut proses latar belakang (background
processes).
Kita dapat mendefinisikan sebuah proses atau program
sebagai proses latar belakang dengan meletakkan karakter '&'
pada akhir perintah. Dengan demikian kita dapat menjalankan
program lain tanpa harus menunggu program atau proses latar
belakang selesai.

$ ls -l /etc | sort > isi &
115 (nomor id proses)
$ date (proses pertama belum selesai)
Fri Oct 23 07:28:32 PDT 1992
$

Proses latar belakang dijalankan bila proses yang
berhubungan dengan terminal sedang menunggu. Pada umumnya
program yang berjalan dengan waktu cukup lama akan
dilaksanakan dengan prioritas rendah di latar belakang.
Untuk melihat status proses yang dijalankan oleh sistem
kita gunakan perintah ps sebagai berikut:

$ ps
PID TTY TIME CMD
35 01 0:02 sh
77 01 0:00 ps
$
Status proses secara lengkap dapat dilihat dengan
menggunakan pilihan -l pada perintah ps sebagai berikut:

$ ps -l
F S UID PID PPID CPU PRI NICE ADDR SZ WCHAN TTY TIME CMD
1 S 101 89 1 3 30 20 5512 12 50602 02 0:02 sh
1 R 101 183 89 52 53 20 6021 22 02 0:02 ps l
$

Penjelasan kode status perintah ps -l:
F proses flag
01 core
02 proses pertukaran dari sistem
04 proses terkunci dalam RAM
10 proses sedang ditukar
20 proses sedang dicari
S keaadan proses
O Non eksisten
S tidur
W menunggu
R berjalan
I intermediate
Z diakhiri
UID id pemakai dari pemilik proses
PID id proses
PPID PID dari proses ayah
C penggunaan prosesor untuk penjadwalan
PRI prioritas proses (0 s/d 120)
NI digunakan dalam komputasi prioritas
ADDR Alamat memori dari proses bila dalam memori
Alamat disket dari proses bila tidak di dalam
memori
SZ ukuran image proses memori dalam 512 byte blok
WCHAN kejadian dengan proses sedang tidur atau menunggu
TTY terminal yang mengendalikan proses
TIME waktu kumulatif pengerjaan
CMD Perintah dan argumennya


4.4 MENGHENTIKAN PROSES DENGAN PERINTAH kill

Untuk menghentikan sebuah proses yang dijalankan di
latar belakang dapat digunakan perintah kill. Untuk
melakukan penghentian proses tersebut kita perlu mengetahui
nomor id proses atau PID dari proses yang bersangkutan.

kill PID

Nomor id proses dapat dilihat dari keluaran balik
dari sistem ketika perintah dilaksanakan dengan proses latar
belakang.

$ troff doc &
56 (nomor id proses)
$
atau dapat dilihat dengan menggunakan perintah ps.

$ troff doc &
56 (nomor id proses)
$ ps
PID TTY TIME CMD
35 01 0:05 sh
56 01 0:02 troff doc (proses troff !)
77 01 0:01 ps
$

Perhatikan contoh untuk menghentikan proses berikut
ini:

$ troff doc &
56 (nomor id proses)
$ ps
PID TTY TIME CMD
35 01 0:05 sh
56 01 0:02 troff doc (hapus !)
77 01 0:01 ps
$ kill 56
$ ps
PID TTY TIME CMD
35 01 0:09 sh
99 01 0:01 ps
$

Perintah kill bekerja dengan mengirimkan sebuah sinyal
pada proses. Perintah kill dapat mengirim bermacam-macam
sinyal sesuai dengan kebutuhannya. Proses yang bekerja hanya
berhenti jika sinyal yang dikirim sesuai. Nilai default
dari sinyal untuk perintah kill adalah 15, yaitu sinyal
terminasi.
Beberapa proses dapat dihentikan dengan menggunakan
sinyal 15 namun proses tersebut masih tetap berjalan dan
tidak mengakhirinya. Bila hal ini terjadi, gunakanlah sinyal
9 untuk mengakhiri proses tersebut.

$ kill -9 115
$


4.5 MENJADUALKAN PROSES DENGAN PERINTAH at

Terkadang kita menginginkan suatu proses dilakukan pada
waktu yang kita jadualkan. Untuk maksud tersebut dapat kita
gunakan perintah at yang diikuti dengan jadual waktu
pelaksanaan perintah dan perintah-perintah yang
dijadualkan. Selanjutnya sistem akan memberikan respon
dengan menampilkan nomor id penjadualan dan waktu
pelaksanaan proses. Nomor id penjadualan ini berfungsi untuk
membatalkan proses yang telah dijadualkan.


$ at 1200
echo waktunya makan siang !
^D
726428280.a Thu Jan 7 12:00:00 1993
$

Perintah ini akan mengeksekusi perintah echo pada pukul
12.00. Keluaran dari perintah echo tersebut akan dikirim
secara otomatis kepada kita melalui electronic mail.
(Penggunaan electronic mail akan dijelaskan pada bab
selanjutnya).
Jika perintah yang dieksekusi tidak menghasilkan
keluaran atau jika keluaran dari perintah yang dieksekusi di
arahkan ke file, maka tidak ada pesan yang kita terima dari
electronic mail, kecuali jika perintah yang dieksekusi
mengalami kesalahan.

$ at 1600
ls -al > listfile
^D
726428280.a Thu Jan 7 16:00:00 1993
$

Kita juga dapat menjadualkan beberapa perintah
sekaligus sebagai berikut:

$ at 1600
ls -al /tmp/*
rm /tmp/*
ls -al /usr/tmp/*
rm /usr/tmp/*
^D
726428280.a Thu Jan 7 16:00:00 1993
$

Format jadual waktu yang digunakan perintah at
bermacam-macam. Kita dapat menggunakan format waktu 24 jam,
misalnya:

- pukul 8.30 pagi dinyatakan 0830
- pukul 1.45 siang dinyatakan 1345
- pukul 8 malam dinyatakan 20

Atau kita juga dapat menggunakan tanda am dan pm pada
jadual waktu sebagai berikut:

- pukul 8.30 pagi dinyatakan 8:30am
- pukul 1.45 siang dinyatakan 1:45pm
- pukul 8 malam dinyatakan 8pm

Pukul 12 siang dan malam dibedakan dengan noon dan
midnight sebagai berikut:

- pukul 12.00 siang dinyatakan 12noon
- pukul 12.00 malam dinyatakan 12midnight

Kita dapat juga menjadualkan berdasarkan menit
(minutes), jam (hours), hari (days), minggu (weeks), bulan
(months) dan tahun (years).

- at 4am Fri + 1 week
- at now + 1 year
- at now + 1 hour
- at 4 jun 20
- at 12midnight jul 4, 1993
- at 7:30pm today

Untuk melihat daftar proses yang telah dijadualkan dan
belum dilaksanakan, dapat digunakan perintah at dengan
pilihan -l sebagai berikut:

$ at -l
726428280.a Thu Jan 7 09:38:00 1993
726428281.a Mon Jan 11 09:38:01 1993
726428292.a Fri Jan 8 10:00:04 1993
726428302.a Thu Jan 7 10:08:12 1993
726428309.a Thu Jan 7 10:17:07 1993
$

Sayangnya yang ditampilkan hanyalah nomor id
penjadualan dan waktu pelaksanaannya saja. Kita tidak dapat
mengetahui proses apa yang akan dilaksanakan.
Untuk membatalkan proses yang telah kita jadualkan
dapat digunakan perintah at dengan pilihan -r.

$ at -l (lihat ..)
726428280.a Thu Jan 7 09:38:00 1993
726428281.a Mon Jan 11 09:38:01 1993
726428292.a Fri Jan 8 10:00:04 1993
726428302.a Thu Jan 7 10:08:12 1993
726428309.a Thu Jan 7 10:17:07 1993
$ at -r 726428292.a 726428302.a (batalkan ..)
$ at -l (lihat ..)
726428280.a Thu Jan 7 09:38:00 1993
726428281.a Mon Jan 11 09:38:01 1993
726428309.a Thu Jan 7 10:17:07 1993
$