PENANGANAN EKSEPSI

PENANGANAN EKSEPSI
Eksepsi adalah keadaan tidak normal yang muncul pada suatu bagian program pada saat dijalankan. Penanganan
eksepsi pada java membawa pengelolaan kesalahan program saat dijalankan kedalam orientasi-objek. Eksepsi java adalah
objek yang menjelaskan suatu keadaan eksepsi yang muncul pada suatu bagian program.
Saat suatu keadaan eksepsi muncul, suatu objek exception dibuat dan dimasukkan ke dalam method yang
menyebabkan eksepsi. Method tersebut dapat dipilih untuk menangani eksepsi berdasarkan tipe tertentu. Method ini juga
menjaga agar tidak keluar terlalu dini melalui suatu eksepsi, dan memiliki suatu blok program yang dijalankan tepat sebelum
suatu eksepsi menyebabkan metodenya kembali ke pemanggil.
Eksepsi dapat muncul tidak beraturan dalam suatu method, atau dapat juga dibuat secara manual dan nantinya
melaporkan sejumlah keadaan kesalahan ke method yang memanggil.
Dasar-dasar penanganan Eksepsi
Penanganan eksepsi pada java diatur dengan lima kata kunci : try, catch, throw, throws dan finally. Pada dasarnya
try digunakan untuk mengeksekusi suatu bagian program, dan jika muncul kesalahan, sistem akan melakukan
throw suatu eksepsi yang dapat anda catch berdasarkan tipe eksepsinya, atau yang anda berikan finally dengan
penangan default.
Berikut ini bentuk dasar bagian penanganan eksepsi :
try {
// Block of Code
}
catch (ExceptionType1 e) {
// Exception Handler for ExceptionType1
}
catch (ExceptionType2 e) {
// Exception Handler for ExceptionType2
throw (e); // re-throw the Exception…
}
finally { }
Tipe Eksepsi
Dipuncak hirarki class eksepsi terdapat satu class yang disebut throwable. Class ini digunakan untuk
merepresentasikan semua keadaan ekasepsi. Setiap ExceptionType pada bentuk umum diatas adalah subclass dari
throwable.
Dua subclass langsung throwable didefinisikan untuk membagi class throwable menjadi dua cabang yang berbeda.
Satu, class Exception, digunakan untuk keadaan eksepsi yang harus ditangkap oleh program yang kita buat. Sedangkan
yang lain diharapkan dapat menangkap class yang kita subclasskan untuk menghasilkan keadaan eksepsi.
Cabang kedua throwable adalah class error, yang mendefinisikan keadaan yang tidak diharapkan untuk ditangkap
dalam lingkungan normal.
Eksepsi Yang Tidak Dapat Ditangkap
Obyek eksepsi secara otomatis dihasilkan oleh runtime java untuk menanggapi suatu keadaan eksepsi. Perhatikan
contoh berikut :
class Exc0 {
public static void main (String args[]) {
int d = 0;
int a = 42 / d;
}
}
Saat runtime java mencoba meng-eksekusi pembagian, akan terlihat bahwa pembaginya adalah nol, dan akan
membentuk objek eksepsi baru yang menyebabkan program terhenti dan harus berurusan dengan keadaan kesalahan
tersebut. Kita belum mengkodekan suatu penangan eksepsi, sehingga penanganan eksepsi default akan segera dijalankan.
Keluaran dari program diatas :
java.lang.ArithmeticExpression : /by zero
at Exc0.main (Exc0.java:4)
Berikut adalah contoh lainnya dari eksepsi :
class Exc1 {
static void subroutine() {
int d = 0;
int a = 42 / d;
}
public static void main (String args[]) {
Exc1.subroutine();
}
}
Output-nya :
Exception in thread “ main” java.lang.ArithmeticException : / by zero
at Exc1.subroutine(Exc1.java :4)
at Exc1.main(Exc1.java : 7)
Try dan Catch
Kata kunci try digunakan untuk menentukan suatu blok program yang harus dijaga terhadap semua eksepsi,
setelah blok try masukkan bagian catch, yang menentukan tipe eksepsi yang akan ditangkap. Perhatikan contoh berikut
:
class Exc2 {
public static void main (String args[]) {
try {
int d = 0;
int a = 42 / d;
}
catch (ArithmeticException e) {
System.out.println(“Division By Zero”);
}
}
}
Throw
Pernyataan throw digunakan untuk secara eksplisit melemparkan suatu eksepsi. Pertama kita harus mendapatkan
penanganan dalam suatu instance throwable, melalui suatu parameter kedalam bagian catch, atau dengan membuatnya
menggunakan operator new. Bentuk umum pernyataan throw :
throw ThrowableInstance;
Aliran eksekusi akan segera terhenti setelah pernyataan throw, dan pernyataan selanjutnya tidak akan dicapai. Blok
try terdekat akan diperiksa untuk melihat jika telah memiliki bagian catch yang cocok dengan tipe instance Throwable. Jika
tidak ditemukan yang cocok, maka pengaturan dipindahkan ke pernyataan tersebut. Jika tidak, maka blok pernyataan try
selanjutnya diperiksa, begitu seterusnya sampai penanganan eksepsi terluar menghentikan program dan mencetak
penelusuran semua tumpukan sampai pernyataan throw. Contoh :
class throwDemo {
static void demoProc() {
try {
throw new NullPointerException(“demo”); }
catch (NullPointerException e) {
System.out.println(“caught inside demoproc”);
throw e; }
}
public static void main (String args[]) {
try { demoProc(); }
catch (NullPointerException e) {
System.out.println(“recaugt : “ + e); }
} }
Output :
caught inside demoproc
recaught : java.lang.NullPointerException : demo
Throws
Kata kunci throws digunakan untuk mengenali daftar eksepsi yang mungkin di-throw oleh suatu method. Jika tipe
eksepsinya adalah error, atau RuntimeException, atau suatu subclassnya, aturan ini tidak berlaku, karena tidak diharapkan
sebagai bagian normal dari kerja program.
Jika suatu method secara eksplisit men-throws suatu intans dari Exception atau subclassnya, diluar
RuntimeException, kita harus mendeklarasikan tipenya dengan pernyataan throws. ini mendefinisikan ulang deklarasi
method sebelumnya dengan sintaks sbb :
type method-name (arg-list) throws exception-list { }
Contoh :
class ThrowsDemo {
static void procedure () throws IllegalAccessException {
System.out.println(“Inside Procedure”);
throw new IllegalAccessException(“demo”);
}
public static void main(String args[]) {
try { procedure(); }
catch (IllegalAccessException e) {
System.out.println(“caught “+ e); }
}
}
Output :
Inside procedure
caught java.lang.IllegalAccessException : demo
Finally
Saat suatu eksepsi dilemparkan, alur program dalam suatu method membuat jalur yang cenderung tidak linier
melalui method tersebut, melompati baris-baris tertentu, bahkan mungkin akan keluar sebelum waktunya pada kasus dimana
tidak ada bagian catch yang cocok. Kadang-kadang perlu dipastikan bahwa bagian program yang diberikan akan berjalan,
tidak perduli eksepsi apa yang terjadi dan ditangkap. Kata kunci finally dapat digunakan untuk menentukan bagian program
seperti itu.
Setiap try membutuhkan sekurang-kurangnya satu bagian catch atau finally yang cocok. Jika kita tidak
mendapatkan bagian catch yang cocok, maka bagian finally akan dieksekusi sebelum akhir program, atau setiap kali suatu
method akan kembali ke pemanggilnya, melalui eksepsi yang tidak dapat ditangkap, atau melalui pernyataan return, bagian
finally akan dieksekusi sebelum kembali ke method kembali.
Berikut adalah contoh program yang menunjukkan beberapa method yang keluar dengan berbagai cara, tidak satu
pun tanpa mengeksekusi bagian finally-nyA.
class finallyDemo {
static void procA() {
try { System.out.println(“Inside procA..”);
throw new RuntimeException(“Demo”); }
finally { System.out.println(“procA is finally”); }
}
static void procB() {
try { System.out.println(“Inside procB..”);
return; }
finally { System.out.println(“procB is finally”); }
}
public static void main(String args[]) {
try { procA( ); }
catch (Exception e){ };
procB(); }
}
Output :
Inside procA..
procA is finally
Inside procB..
procB is finally
Multithreading
Banyak persoalan dalam pemrograman membutuhkan kemampuan suatu program untuk melakukan beberapa hal
sekaligus, atau memberikan penanganan segera terhadap suatu kejadian/ event tertentu dengan menunda aktivitas yang
sedang dijalankan untuk menangani event tersebut dan akhirnya kembali melanjutkan aktivitas yang tertunda.
Contoh, dalam sistem aplikasi jaringan, kita dapat membuat suatu program melakukan komputasi lokal dengan data
yang sudah didapat dari jaringan, pada saat program tersebut menunggu datangnya tambahan data dari jaringan. Tanpa
multithreading, program tersebut harus melakukannya secara sekuensial dalam sebuah alur program tunggal (yaitu alur
control utama), yang diawali dengan penantian tibanya keseluruhan data, baru kemudian komputasi. Pada masa penantian
tersebut, komputer berada pada keadaan idle yang menyebabkan ketidakefisienan pada keseluruhan program.
Dengan multithreading kita dapat menciptakan dua thread secara dinamis, yaitu thread yang berjaga dipintu
gerbang, menunggu masuknya data., dan thread yang melakukan komputasi lokal atas data yang sudah tersedia.
Multithreading dan Java
Thread (seringkali disebut juga lightweight process atau execution context) adalah sebuah singlesequentialflow of
control didalam sebuah program. Secara sederhana, thread adalah sebuah subprogram yang berjalan didalam sebuah
program.
Seperti halnya sebuah program, sebuah thread mempunyai awal dan akhir. Sebuah program dapat mempunyai
beberapa thread didalamnya. Jadi perbedaannya program yang multithreaded mempunyai beberapa flow of control yang
berjalan secara konkuren atau paralel sedangkan program yang singlethreaded hanya mempunyai satu flow of control.
Sebuah Program
Gb.1. Dua thread dalam satu program
Dua program yang dijalankan secara terpisah ( dari command line secara terpisah ), berada pada dua address
space yang terpisah. Sebaliknya, kedua thread pada gambar diatas berada pada address space yang sama (address space
dari program dimana kedua thread tersebut dijalankan).
Kalau program itu berjalan diatas mesin dengan single processor, maka thread-thread itu dijalankan secara
konkuren(dengan mengeksekusi secara bergantian dari satu thread ke thread yang lainnya). Jika program itu berjalan diatas
mesin dengan multiple processor, maka thread-thread itu bisa dijalankan secara paralel (masing-masing thread berjalan di
processor yang terpisah).
Gambar 2 dapat menjelaskan perbedaan antara konkurensi dan parallelism. Bahasa Java mempunyai kemampuan
multithreading built-in, pada Java Virtual Macjine terdapat thread scheduler yang menentukan thread mana yang beraksi
pada selang waktu tertentu. Scheduler pada JVM mendukung preemptive multithreading, yaitu suatu thread dengan prioritas
tinggi dapat menyeruak masuk dan menginterupsi thread yang sedang beraksi, kemampuan ini sangat menguntungkan
dalam membuat aplikasi real-time.
Scheduler pada JVM juga mendukung non-preemptive multithreading I(atau sering disebut juga cooperative
multithreading), yaitu thread yang sedang beraksi tidak dapat diinterupsi, ia akan menguasai waktu CPU, sampai ia
menyelesaikan tugasnya atau secara eksplisit merelakan diri untuk berhenti dan memberi kesempatan bagi thread yang lain.
Newborn
Sevbuah thread berada pada state ini ketika dia di instantiasi. Sebuah ruangan dimemori telah dialokasikan untuk
thread itu,dan telah menyelesaikan tahap inisialisasinya.
………
Thread timerThread = new TimerThread();
……..
Pada state ini, timeThread belum masuk dalam skema penjadwalan thread scheduler.
Runnable
Pada state ini, sebuah thread berada dalam skema penjadwalan, akan tetapi dia tidak sedang beraksi. Kita bisa
membuat timerThread yang kita buat sebelumnya masuk ke state runnable dengan :
…..
timerThread.start();
……
Kapan tepatnya timerThread beraksi, ditentukan oleh thread scheduler.
Running
Pada state ini, thread sedang beraksi. Jatah waktu beraksi bagi thread ini ditentukan oleh thread scheduler. Pada
kasus tertentu, thread scheduler berhak meng-interupsikegiatan dari thread yang seddang beraksi (misalnya ada thread
lainnya dengan prioritas yang lebih tinggi).
Thread dalam keadaan running bisa juga lengser secara sukarela, dan masuk kembali ke state runnable, sehingga
thread lain yang sedang menunggu giliran(runnable) memperoleh kesempatan untuk beraksi. Tinddakan thread yang lengser
secara sukarela itu biasanya disebut yield-ing.
public void run() {
…….
Thread.yield();
…….
}
Blocked
Pada tahap inii thread sedang tidak beraksi dan diabaikan dalam penjadwalan thread scheduler. Thread yang
sedang terblok menunggu sampai syarat-syarat tertentu terpenuhi, sebelum ia kembali masuk kedalam skema penjadwalan
thread scheduler (masuk state runnable lagi). Suatu thread menjadi terblok karena hal-hal berikut :
a. Thread itu tidur untuk jangka waktu tertentu, seperti berikut :
public void run() {
……
try {
thread.slepp(3000);
//thread yg sedang beraksi akan tidur selama 3000 milisecond=3menit
}
catch (InterruptedException e) {
…….
}
b. Thread itu di- suspend(). Thread yang ter-suspend() itu bisa masuk kembali ke state runnable bila ia resume().
seperti hal berikut :
……
//timerThread akan segera memasuki state blocked
timerThread.suspend();
………
timerThread.resume();
//timerThread kembali masuk state runnable
……
c. Bila thread tersebut memanggil method wait() dari suatu object yang sedang ia kunci. Thread tersebut bisa kembali
memasuki state runnable bila ada thread lain yang memanggil method notify() atau notifyAll() dari object tersebut.
d. Bila thread ini menunggu selesainya aktifitas yang berhubungan dengan I/O. Misalnya, jika suatu thread menunggu
datangnya bytes dari jaringan komputer maka secara otomatis thread tersebut masuk ke state blocked.
e. Bila suatu thread mencoba mengakses critical section dari suatu object yang sedang dikunci oleh thread lain.
Critical section adalah method/blok kode yang ditandai dengan kata synchronized.
Dead
Suatu thread secara otomatis disebut mati bila method run() – nya sudah dituntaskan (return dari method run() ).
Contoh dibawah ini adalah thread yang akan mengecap state running hanya sekali saat thread scheduler memberinya
kesempatan untuk running, ia akan mencetak “ I’m doing something….something stupid….but I’m proud of It”… kemudian
mati.
public class MyThread extends Thread {
…..
public void run() {
System.out.print(“I’m doing something…”);
System.out.print(“something stupid…”);
System.out.println(“but I’m proud of It…”);
// MyThread akan mati begitu baris diatas selesai dieksekusi
}
……
}
contoh :
1. class theThread implements Runnable{
2. Thread t;
3.
4. theThread(){ t = new Thread(this, "DemoThread");
5. System.out.println("Child Thead : " + t);
6. t.start(); }
7.
8. public void run(){
9. try{ for(int i=5;i>0;i--){
10. System.out.println("Child Thread :" + i);
11. Thread.sleep(500); }
12. }
13. catch(InterruptedException e){
14. System.out.println("Child Interrupted"); }
15. System.out.println("Exiting Child Thread"); }
16. }
17. class MyThread{
18. public static void main(String args[]){
19. new theThread();
20. try{ for(int i=5;i>0;i--){
21. System.out.println("Main Thread :" + i);
22. Thread.sleep(1000); }
23. }
24. catch(InterruptedException e){
25. System.out.println("main Interrupted"); }
26. System.out.println("Exiting Main Thread"); }
27. }
Output :
Child Thread : Thread(Demo Thread, 5, main)
Main Thread : 5
Child Thread : 5
Child Thread : 4
Main Thread : 4
Child Thread : 3
Child Thread : 2
Main Thread : 3
Child Thread : 1
Exiting Child Thread
Main Thread : 2
Main Thread : 1
Exiting Main Thread