Java Multithreading (3): Materi dan Bahasan Secara Umum

Thread Scheduler pada Java

Task Scheduler yaitu adalah bagian dari JVM yang memutuskan utas mana yang harus dijalankan. Tidak ada jaminan bahwa utas yang dapat dijalankan mana yang akan dipilih untuk dijalankan oleh penjadwal utas. Hanya satu utas dalam satu waktu yang dapat berjalan dalam satu proses. Penjadwal utas terutama menggunakan penjadwalan preemptive atau pembagian waktu untuk menjadwalkan utas.

Perbedaan antara Penjadwalan Preemptive dan Time Slicing

Di bawah penjadwalan preemptive, tugas prioritas tertinggi dijalankan hingga memasuki status menunggu atau mati atau tugas dengan prioritas lebih tinggi muncul. Di bawah pembagian waktu, tugas dijalankan untuk potongan waktu yang telah ditentukan dan kemudian memasukkan kembali kumpulan tugas yang siap. Penjadwal kemudian menentukan tugas mana yang harus dijalankan selanjutnya, berdasarkan prioritas dan faktor lainnya.

Metode Sleep pada Java

Metode sleep () dari kelas Thread digunakan untuk mengaktifkan thread selama waktu yang ditentukan. Kelas Thread menyediakan dua metode untuk mengaktifkan thread yaitu

1. public static void sleep (milidetik panjang) melempar InterruptedException.
2. public static void sleep (milidetik panjang, nanos int) melempar InterruptedException

Contoh penggunaan metode Sleep () pada Java

class TestSleepMethod1 extends Thread{  
 public void run(){  
  for(int i=1;i<5;i++){  
    try{Thread.sleep(500);}catch(InterruptedException e){System.out.println(e);}  
    System.out.println(i);  
  }  
 }  
 public static void main(String args[]){  
  TestSleepMethod1 t1=new TestSleepMethod1();  
  TestSleepMethod1 t2=new TestSleepMethod1();  
   
  t1.start();  
  t2.start();  
 }  
}  

Maka akan menghasilkan output berikut

1
1
2
2
3
3
4
4

Seperti yang Anda ketahui bahwa dalam satu waktu hanya satu utas yang dijalankan. Jika Anda tidur utas untuk waktu yang ditentukan, utas shedular mengambil utas lain dan seterusnya.

Menjalankan Thread 2 kali, Apakah Bisa ?

Tidak. Setelah memulai utas, utas tidak dapat dimulai lagi. Jika Anda melakukannya, IllegalThreadStateException akan muncul. Dalam kasus seperti itu, utas akan berjalan sekali tetapi untuk kedua kalinya, itu akan memunculkan pengecualian.

Untuk menjelaskan pengertian diatas maka dapat dilihat pada kode berikut

public class TestThreadTwice1 extends Thread{  
 public void run(){  
   System.out.println("running...");  
 }  
 public static void main(String args[]){  
  TestThreadTwice1 t1=new TestThreadTwice1();  
  t1.start();  
  t1.start();  
 }  
}  

Maka akan menghasilkan output seperti ini

running
Exception in thread "main" java.lang.IllegalThreadStateException

Bagaimana jika kita memanggil metode run () secara langsung sebagai ganti metode start () ?

Setiap thread dimulai dalam tumpukan panggilan terpisah.
Memanggil metode run () dari utas utama, metode run () masuk ke tumpukan panggilan saat ini daripada di awal tumpukan panggilan baru. Kemudian dapat dilihat dari contoh kode berikut

class TestCallRun1 extends Thread{  
 public void run(){  
   System.out.println("running...");  
 }  
 public static void main(String args[]){  
  TestCallRun1 t1=new TestCallRun1();  
  t1.run();//fine, but does not start a separate call stack  
 }  
}  // akan menghasilkan output seperti : Output:running...

Contoh kode lainnya yang dapat kita buat yaitu

class TestCallRun2 extends Thread{  
 public void run(){  
  for(int i=1;i<5;i++){  
    try{Thread.sleep(500);}catch(InterruptedException e){System.out.println(e);}  
    System.out.println(i);  
  }  
 }  
 public static void main(String args[]){  
  TestCallRun2 t1=new TestCallRun2();  
  TestCallRun2 t2=new TestCallRun2();  
   
  t1.run();  
  t2.run();  
 }  
}

Kita akan memiliki output berikut ini

Output:1
       2
       3
       4
       5
       1
       2
       3
       4
       5

Seperti yang Anda lihat pada program di atas bahwa tidak ada pengalihan konteks karena di sini t1 dan t2 akan diperlakukan sebagai objek normal bukan objek utas.

Metode Join() pada Java

Metode join () menunggu thread mati. Dengan kata lain, ini menyebabkan utas yang sedang berjalan berhenti dijalankan sampai utas yang bergabung dengannya menyelesaikan tugasnya. Sintaks yang biasanya ada pada java yaitu

1. public void join()throws InterruptedException.
2. public void join(long milliseconds)throws InterruptedException

Contoh sederhana dari sebuah metode join() adalah

class TestJoinMethod1 extends Thread{  
 public void run(){  
  for(int i=1;i<=5;i++){  
   try{  
    Thread.sleep(500);  
   }catch(Exception e){System.out.println(e);}  
  System.out.println(i);  
  }  
 }  
public static void main(String args[]){  
 TestJoinMethod1 t1=new TestJoinMethod1();  
 TestJoinMethod1 t2=new TestJoinMethod1();  
 TestJoinMethod1 t3=new TestJoinMethod1();  
 t1.start();  
 try{  
  t1.join();  
 }catch(Exception e){System.out.println(e);}  
  
 t2.start();  
 t3.start();  
 }  
}  

Kemudian kode diatas akan menghasilkan output berikut

Output:1
       2
       3
       4
       5
       1
       1
       2
       2
       3
       3
       4
       4
       5
       5

Seperti yang Anda lihat pada contoh di atas, ketika t1 menyelesaikan tugasnya, t2 dan t3 mulai dijalankan. Kemudian kita dapat membuat contoh baru untuk metode join (long miliseconds) seperti kode dibawah ini

class TestJoinMethod2 extends Thread{  
 public void run(){  
  for(int i=1;i<=5;i++){  
   try{  
    Thread.sleep(500);  
   }catch(Exception e){System.out.println(e);}  
  System.out.println(i);  
  }  
 }  
public static void main(String args[]){  
 TestJoinMethod2 t1=new TestJoinMethod2();  
 TestJoinMethod2 t2=new TestJoinMethod2();  
 TestJoinMethod2 t3=new TestJoinMethod2();  
 t1.start();  
 try{  
  t1.join(1500);  
 }catch(Exception e){System.out.println(e);}  
  
 t2.start();  
 t3.start();  
 }  
}  

Output pada kode diatas adalah

Output:1
       2
       3
       1
       4
       1
       2
       5
       2
       3
       3
       4
       4
       5
       5

Dalam contoh di atas, ketika t1 selesai tugasnya selama 1500 milidetik (3 kali) maka t2 dan t3 mulai dijalankan.

Metode getName(), setName(String) dan getId()

Pada Java juga terdapat 3 metode yang penting yaitu

1. public String getName().
2. public void setName(String name).
3. public long getId().

Contohnya untuk metode diatas yaitu

class TestJoinMethod3 extends Thread{  
  public void run(){  
   System.out.println("running...");  
  }  
 public static void main(String args[]){  
  TestJoinMethod3 t1=new TestJoinMethod3();  
  TestJoinMethod3 t2=new TestJoinMethod3();  
  System.out.println("Name of t1:"+t1.getName());  
  System.out.println("Name of t2:"+t2.getName());  
  System.out.println("id of t1:"+t1.getId());  
  
  t1.start();  
  t2.start();  
  
  t1.setName("Sonoo Jaiswal");  
  System.out.println("After changing name of t1:"+t1.getName());  
 }  
}  

Selanjutnya akan kita dapatkan hasil berikut

Output:Name of t1:Thread-0
       Name of t2:Thread-1
       id of t1:8
       running...
       After changling name of t1:Sonoo Jaiswal
       running...

Metode currentThread()

Metode currentThread () mengembalikan referensi ke objek thread yang sedang dieksekusi. Kemudian sintaks yang digunakan biasanya adalah

public static Thread currentThread()

Kita juga dapat membuat contoh dari metode currentThread() seperti ini

class TestJoinMethod4 extends Thread{  
 public void run(){  
  System.out.println(Thread.currentThread().getName());  
 }  
 }  
 public static void main(String args[]){  
  TestJoinMethod4 t1=new TestJoinMethod4();  
  TestJoinMethod4 t2=new TestJoinMethod4();  
  
  t1.start();  
  t2.start();  
 }  
}  

Outputnya akan menghasilkan

Output:Thread-0
       Thread-1

Penamaan Thread dan Current Thread

Penamaan Thread

Kelas Thread menyediakan metode untuk mengubah dan mendapatkan nama thread. Secara default, setiap utas memiliki nama yaitu utas-0, utas-1, dan seterusnya. Dengan kita dapat mengubah nama utas dengan menggunakan metode setName (). Sintaks metode setName () dan getName () diberikan di bawah ini:

1. public String getName () yaitu digunakan untuk mengembalikan nama thread.
2. public void setName (String name) yaitu digunakan untuk mengubah nama thread.

Kemudian kita akan membuat contoh dalam penamaan thread yaitu

class TestMultiNaming1 extends Thread{  
  public void run(){  
   System.out.println("running...");  
  }  
 public static void main(String args[]){  
  TestMultiNaming1 t1=new TestMultiNaming1();  
  TestMultiNaming1 t2=new TestMultiNaming1();  
  System.out.println("Name of t1:"+t1.getName());  
  System.out.println("Name of t2:"+t2.getName());  
   
  t1.start();  
  t2.start();  
  
  t1.setName("Sonoo Jaiswal");  
  System.out.println("After changing name of t1:"+t1.getName());
 }  
} 

Outputnya akan menjadi

Output:Name of t1:Thread-0
       Name of t2:Thread-1
       id of t1:8
       running...
       After changeling name of t1:Sonoo Jaiswal
       running...

Current Thread

Metode currentThread () mengembalikan referensi utas yang saat ini dieksekusi. Sintaks ini dapat ditulis dengan cara

public static Thread currentThread()  

Kemudian kita akan membuat contoh current thread seperti berikut

Class TestMultiNaming2 extends Thread{  
 public void run(){  
  System.out.println(Thread.currentThread().getName());  
 }  
 public static void main(String args[]){  
  TestMultiNaming2 t1=new TestMultiNaming2();  
  TestMultiNaming2 t2=new TestMultiNaming2();  
  
  t1.start();  
  t2.start();  
 }  
}  

Output yang dihasilkan yaitu

Output:Thread-0
       Thread-1

Thread Priority pada Java

Setiap thread memiliki prioritas. Prioritas diwakili oleh angka antara 1 dan 10. Dalam kebanyakan kasus, penjadwalan thread menjadwalkan thread sesuai dengan prioritasnya (dikenal sebagai penjadwalan preemptive). Namun tidak dijamin karena tergantung spesifikasi JVM yang dipilih penjadwalannya.

Mendefinisi Nilai Konstan pada Kelas Thread

1. public static int MIN_PRIORITY.
2. public static int NORM_PRIORITY.
3. public static int MAX_PRIORITY.

Prioritas default thread adalah 5 (NORM_PRIORITY). Nilai MIN_PRIORITY adalah 1 dan nilai MAX_PRIORITY adalah 10.

Contoh kode pada Java mengenai prioritas dalam sebuah Thread

class TestMultiPriority1 extends Thread{  
 public void run(){  
   System.out.println("running thread name is:"+Thread.currentThread().getName());
System.out.println("running thread priority is:"+Thread.currentThread().getPriority());  
  
  }  
 public static void main(String args[]){  
  TestMultiPriority1 m1=new TestMultiPriority1();  
  TestMultiPriority1 m2=new TestMultiPriority1();  
  m1.setPriority(Thread.MIN_PRIORITY);  
  m2.setPriority(Thread.MAX_PRIORITY);  
  m1.start();  
  m2.start();  
   
 }  
}     

Outputnya akan menjadi seperti ini

Output:running thread name is:Thread-0
       running thread priority is:10
       running thread name is:Thread-1
       running thread priority is:1

Daemon Thread pada Java

Daemon Threads di java adalah threads penyedia layanan yang menyediakan layanan ke utas pengguna. Hidupnya tergantung pada belas kasihan utas pengguna yaitu ketika semua utas pengguna mati, JVM menghentikan utas ini secara otomatis.

Ada banyak utas daemon java yang berjalan secara otomatis, mis. gc, finalizer dan lainnya. Anda dapat melihat semua detail dengan mengetik jconsole di command prompt. Alat jconsole memberikan informasi tentang kelas yang dimuat, penggunaan memori, menjalankan thread.

Hal Penting pada Daemon Thread

• Ini menyediakan layanan ke utas pengguna untuk tugas pendukung latar belakang. Itu tidak memiliki peran dalam kehidupan selain melayani utas pengguna.
• Hidupnya tergantung pada utas pengguna.
• Ini adalah utas dengan prioritas rendah.

Satu-satunya tujuan daemon thread adalah menyediakan layanan ke utas pengguna untuk tugas pendukung latar belakang. Jika tidak ada utas pengguna, mengapa JVM harus terus menjalankan utas ini. Itulah sebabnya JVM menghentikan utas daemon jika tidak ada utas pengguna.

Metode pada Daemon Thread dari Kelas Thread

Kelas java.lang.Thread menyediakan dua metode untuk thread daemon java. Metode yang ada pada kelas threads yaitu

1. public void setDaemon (status boolean) yaitu digunakan untuk menandai thread saat ini sebagai thread daemon atau thread pengguna.
2. public boolean isDaemon () yaitu digunakan untuk memeriksa bahwa saat ini adalah daemon.

Contoh sederhana untuk Daemon Thread pada Java dapat kita buat dengan cara menuliskan kode berikut

public class TestDaemonThread1 extends Thread{  
 public void run(){  
  if(Thread.currentThread().isDaemon()){//checking for daemon thread  
   System.out.println("daemon thread work");  
  }  
  else{  
  System.out.println("user thread work");  
 }  
 }  
 public static void main(String[] args){  
  TestDaemonThread1 t1=new TestDaemonThread1();//creating thread  
 TestDaemonThread1 t2=new TestDaemonThread1();  
  TestDaemonThread1 t3=new TestDaemonThread1();  
  
  t1.setDaemon(true);//now t1 is daemon thread  
    
  t1.start();//starting threads  
  t2.start();  
  t3.start();  
 }  
}  

Maka akan menghasilkan output berikut ini

daemon thread work
user thread work
user thread work

Contoh lainnya dapat dibuat dengan menuliskan kode berikut

class TestDaemonThread2 extends Thread{  
 public void run(){  
  System.out.println("Name: "+Thread.currentThread().getName()); 
 System.out.println("Daemon: "+Thread.currentThread().isDaemon());  
 }  
  
 public static void main(String[] args){  
  TestDaemonThread2 t1=new TestDaemonThread2();  
  TestDaemonThread2 t2=new TestDaemonThread2();  
  t1.start();  
  t1.setDaemon(true);//will throw exception here  
  t2.start();  
 }  
}  // output yang dihasilkan yaitu : Output:exception in thread main: java.lang.IllegalThreadStateException

Java Thread Pool

Kumpulan Thread Java mewakili sekelompok thread pekerja yang menunggu pekerjaan dan sering digunakan kembali. Dalam kasus kumpulan utas, sekelompok utas ukuran tetap dibuat. Sebuah utas dari kumpulan utas ditarik keluar dan diberi tugas oleh penyedia layanan. Setelah menyelesaikan pekerjaan, utas berada di kumpulan utas lagi.

Keuntungan dari Java Thread Pool yaitu Performa lebih baik Menghemat waktu karena tidak perlu membuat utas baru. Penggunaan Real Time Ini juga digunakan di Servlet dan JSP di mana wadah membuat kumpulan utas untuk memproses permintaan.

Mari kita lihat contoh sederhana dari kumpulan thread java menggunakan ExecutorService dan Executors. dengan membuat 2 file pada kode dibawah ini yang pertama dengan menuliskan dengan nama WorkerThread.java

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
class WorkerThread implements Runnable {  
    private String message;  
    public WorkerThread(String s){  
        this.message=s;  
    }  
     public void run() {  
        System.out.println(Thread.currentThread().getName()+" (Start) message = "+message);
 processmessage();//call processmessage method that sleeps the thread for 2 seconds  
        System.out.println(Thread.currentThread().getName()+" (End)");//prints thread name
  }  
    private void processmessage() {  
        try {  Thread.sleep(2000);  } catch (InterruptedException e) { e.printStackTrace(); }  
    }  
}  

Selanjutnya file kedua dengan nama JavaThreadPoolExample.java

public class TestThreadPool {  
     public static void main(String[] args) {  
        ExecutorService executor = Executors.newFixedThreadPool(5);//creating a pool of 5 threads
for (int i = 0; i < 10; i++) {  
            Runnable worker = new WorkerThread("" + i);  
            executor.execute(worker);//calling execute method of ExecutorService  
          }  
        executor.shutdown();  
        while (!executor.isTerminated()) {   }  
  
        System.out.println("Finished all threads");  
    }  
 }  

Selanjutnya ketika dijalankan akan menghasilkan output yaitu

pool-1-thread-1 (Start) message = 0
pool-1-thread-2 (Start) message = 1
pool-1-thread-3 (Start) message = 2
pool-1-thread-5 (Start) message = 4
pool-1-thread-4 (Start) message = 3
pool-1-thread-2 (End)
pool-1-thread-2 (Start) message = 5
pool-1-thread-1 (End)
pool-1-thread-1 (Start) message = 6
pool-1-thread-3 (End)
pool-1-thread-3 (Start) message = 7
pool-1-thread-4 (End)
pool-1-thread-4 (Start) message = 8
pool-1-thread-5 (End)
pool-1-thread-5 (Start) message = 9
pool-1-thread-2 (End)
pool-1-thread-1 (End)
pool-1-thread-4 (End)
pool-1-thread-3 (End)
pool-1-thread-5 (End)
Finished all threads

Thread Group pada Java

Java menyediakan cara mudah untuk mengelompokkan beberapa utas dalam satu objek. Dengan cara demikian, kami dapat menangguhkan, melanjutkan, atau menginterupsi grup utas dengan satu panggilan metode. Threads Grup Java diimplementasikan oleh kelas java.lang.ThreadGroup.

ThreadGroup mewakili satu set utas. Grup utas juga dapat menyertakan grup utas lainnya. Grup utas membuat pohon di mana setiap grup utas kecuali grup utas awal memiliki induk. Utas diizinkan untuk mengakses informasi tentang grup utasnya sendiri, tetapi tidak dapat mengakses informasi tentang grup utas grup utasnya atau grup utas lainnya.

Constructor Kelas Thread Group

Hanya ada dua konstruktor kelas ThreadGroup.

1. ThreadGroup (Nama string) membuat grup utas dengan nama yang diberikan.
2. ThreadGroup (induk ThreadGroup, nama String) membuat grup utas dengan grup dan nama induk yang diberikan.

Java Shutdown Hook

Hook shutdown dapat digunakan untuk melakukan pembersihan sumber daya atau menyimpan status saat JVM dimatikan secara normal atau tiba-tiba. Melakukan sumber daya bersih berarti menutup file log, mengirimkan beberapa peringatan atau sesuatu yang lain. Jadi jika Anda ingin mengeksekusi beberapa kode sebelum JVM dimatikan, gunakan hook shutdown.

Kapan JVM melakukan Shutdown ?

JVM akan melakukan shutdown adalah ketika

1. Pengguna menekan ctrl + c pada prompt perintah.
2. Metode System.exit (int) dipanggil.
3. logoff pengguna.
4. User Shutdown.

Metode addShutdownHook(Thread hook) yaitu metode dari kelas Runtime digunakan untuk mendaftarkan threads dengan Mesin Virtual. Sintaks yang digunakan adalah

public void addShutdownHook(Thread hook){}  

Objek kelas Runtime bisa diperoleh dengan memanggil metode pabrik statis getRuntime (). Sebagai contoh adalah Waktu Proses r = Waktu Proses.getRuntime ();

Metode Factory yaitu Metode yang mengembalikan instance kelas dikenal sebagai metode factory.

Contoh Shutdown Hook ini adalah dapat dilihat pada kode berikut

class MyThread extends Thread{  
    public void run(){  
        System.out.println("shut down hook task completed..");  
  }  
}  
  
public class TestShutdown1{  
public static void main(String[] args)throws Exception {  
  
Runtime r=Runtime.getRuntime();  
r.addShutdownHook(new MyThread());  
      
System.out.println("Now main sleeping... press ctrl+c to exit"); 
try{Thread.sleep(3000);}catch (Exception e) {}  
}  
}

Jalankan dan aan menghasilkan output berikut

Output:Now main sleeping... press ctrl+c to exit
       shut down hook task completed..

Contoh Shutdown Hook ini bisa dilihat pada kode dibawah

public class TestShutdown2{  
public static void main(String[] args)throws Exception {  
  
Runtime r=Runtime.getRuntime();  
  
r.addShutdownHook(new Thread(){  
public void run(){  
    System.out.println("shut down hook task completed..");  
    }  
}  
);  
      
System.out.println("Now main sleeping... press ctrl+c to exit");  
try{Thread.sleep(3000);}catch (Exception e) {}  
}  
}  

Kemudian akan didapatkan output

Output:Now main sleeping... press ctrl+c to exit
       shut down hook task completed..

Bagaimana Menjalankan Single Task dengan Multiple Threads ?

Jika Anda harus melakukan satu tugas dengan banyak thread, dengan memiliki hanya satu metode run (). Contohnya dapat dilihat pada contoh kode dibawah ini

class TestMultitasking1 extends Thread{  
 public void run(){  
   System.out.println("task one");  
 }  
 public static void main(String args[]){  
  TestMultitasking1 t1=new TestMultitasking1();  
  TestMultitasking1 t2=new TestMultitasking1();  
  TestMultitasking1 t3=new TestMultitasking1();  
  
  t1.start();  
  t2.start();  
  t3.start();  
 }  
}  

Contoh output yang dihasilkan yaitu

Output:task one
       task one
       task one

Contoh lainnya dapat dilihat dengan contoh kode berikut

class TestMultitasking2 implements Runnable{  
public void run(){  
System.out.println("task one");  
}  
  
public static void main(String args[]){  
Thread t1 =new Thread(new TestMultitasking2());//passing annonymous object of TestMultitasking2 class 
Thread t2 =new Thread(new TestMultitasking2());  
  
t1.start();  
t2.start();  
  
 }  
}  

Contohnya hampir mirip dengan diatas yaitu

Output:task one
       task one

Bagaimana cara melakukan banyak tugas dengan banyak threads (Multitasking dalam Multithreading)?

Jika Anda harus melakukan banyak tugas dengan beberapa threads , dengan memiliki beberapa metode run (). Contohnya langsung saja dapat kita buat dengan menggunakan kode berikut

class Simple1 extends Thread{  
 public void run(){  
   System.out.println("task one");  
 }  
}  
  
class Simple2 extends Thread{  
 public void run(){  
   System.out.println("task two");  
 }  
}  
  
 class TestMultitasking3{  
 public static void main(String args[]){  
  Simple1 t1=new Simple1();  
  Simple2 t2=new Simple2();  
  
  t1.start();  
  t2.start();  
 }  
}

Maka output yang dihasilkan seperti ini

Output:task one
       task two

Contoh lainnya dapat dibuat dengan menggunakan kelas anonim yang mengextends dari kelas Thread

class TestMultitasking4{  
 public static void main(String args[]){  
  Thread t1=new Thread(){  
    public void run(){  
      System.out.println("task one");  
    }  
  };  
  Thread t2=new Thread(){  
    public void run(){  
      System.out.println("task two");  
    }  
  };  
  
  
  t1.start();  
  t2.start();  
 }  
}  

Output:task one
       task two

Kita dapat membuat Contoh lainnya dibuat dengan menggunakan kelas anonim yang Mengimplements Runnable Interfaces dengan kode berikut

class TestMultitasking5{  
 public static void main(String args[]){  
  Runnable r1=new Runnable(){  
    public void run(){  
      System.out.println("task one");  
    }  
  };  
  
  Runnable r2=new Runnable(){  
    public void run(){  
      System.out.println("task two");  
    }  
  };  
      
  Thread t1=new Thread(r1);  
  Thread t2=new Thread(r2);  
  
  t1.start();  
  t2.start();  
 }  
}  

Maka output yang dihasilkan akan sama seperti diatas yaitu

Output:task one
       task two

Java Garbage Collection

Di java, sampah berarti objek yang tidak direferensikan. Pengumpulan Sampah adalah proses mengambil kembali runtime memori yang tidak digunakan secara otomatis. Dengan kata lain, ini adalah cara untuk menghancurkan benda-benda yang tidak digunakan.

Untuk melakukannya, kami menggunakan fungsi free () dalam bahasa C dan delete () dalam C ++. Tapi, di java itu dilakukan secara otomatis. Jadi, java menyediakan manajemen memori yang lebih baik.

Keuntungan Garbage Colllection pada Java yaitu

• Membuat memori java efisien karena pengumpul sampah menghapus objek yang tidak direferensikan dari memori heap.
• Otomatis dilakukan oleh pengumpul sampah (bagian dari JVM) jadi kita tidak perlu melakukan upaya ekstra.

Bagaimana sebuah objek bisa tidak direferensikan? Ada banyak cara yaitu dengan cara dibawah ini

• Dengan membatalkan referensi (nulling the reference).
• Dengan menetapkan referensi ke yang lain (assigning a reference to another).
• Oleh objek anonim (anonymous object).

1. Nulling reference yaitu dengan sintaks

Employee e=new Employee();  
e=null;  

2. Assigning a reference to another yaitu dengan sintaks

Employee e1=new Employee();  
Employee e2=new Employee();  
e1=e2;//now the first object referred by e1 is available for garbage collection  

3. Anonymous Object dengan sintaks

new Employee();  

Metode Finalize () dan Metode gc()

Metode finalize () dipanggil setiap kali sebelum objek dikumpulkan sampah. Metode ini dapat digunakan untuk melakukan pemrosesan pembersihan. Metode ini didefinisikan di kelas Object sebagai kode berikut

protected void finalize(){}

Metode gc () digunakan untuk memanggil pengumpul sampah untuk melakukan pemrosesan pembersihan. Gc () ditemukan di kelas System dan Runtime. Dapat dilihat dengan sintaks

public static void gc(){}  

Contoh dari garbage Collection pada Java yaitu dapat dibuat dengan kode

public class TestGarbage1{  
 public void finalize(){System.out.println("object is garbage collected");}  
 public static void main(String args[]){  
  TestGarbage1 s1=new TestGarbage1();  
  TestGarbage1 s2=new TestGarbage1();  
  s1=null;  
  s2=null;  
  System.gc();  
 }  
}  

Maka akan menghasilkan output berikut

       object is garbage collected
       object is garbage collected

Catatan: Garbage Collection JVM hanya mengumpulkan objek yang dibuat dengan kata kunci baru. Jadi jika Anda telah membuat objek apa pun tanpa yang baru, Anda dapat menggunakan metode finalize untuk melakukan pemrosesan pembersihan (menghancurkan objek yang tersisa). Garbage Collection dilakukan oleh untaian daemon yang disebut Garbage Collector (GC). Utas ini memanggil metode finalize () sebelum objek dikumpulkan sampahnya. Baik finalisasi maupun pengumpulan sampah tidak dijamin.

Kelas Java Runtime

Kelas Java Runtime digunakan untuk berinteraksi dengan lingkungan runtime java. Kelas Java Runtime menyediakan metode untuk menjalankan proses, memanggil GC, mendapatkan total dan memori gratis, dll. Hanya ada satu instance kelas java.lang.Runtime yang tersedia untuk satu aplikasi java.

Metode Runtime.getRuntime () mengembalikan instance tunggal kelas Runtime. Metode yang sangat penting pada kelas Java Runtime adalah

• 1) public static Runtime getRuntime () mengembalikan instance kelas Runtime.
• 2) public void exit (status int) menghentikan mesin virtual saat ini.
• 3) public void addShutdownHook (Thread hook) mendaftarkan thread hook baru.
• 4) Proses publik exec (perintah String) melempar IOException mengeksekusi perintah yang diberikan dalam proses terpisah.
• 5) public int availableProcessors () mengembalikan no. prosesor yang tersedia.
• 6) public long freeMemory () mengembalikan jumlah memori bebas di JVM.
• 7) public long totalMemory () mengembalikan jumlah total memori di JVM.

Metode Java Runtime exec()

Metode ini dapat dibuat dengan cara

public class Runtime1{  
 public static void main(String args[])throws Exception{  
  Runtime.getRuntime().exec("notepad");//will open a new notepad  
 }  
} 

Mematikan Sistem pada Java

Anda dapat menggunakan perintah shutdown -s untuk mematikan sistem. Untuk OS windows, Anda perlu menyediakan jalur lengkap perintah shutdown, mis. c: \ Windows \ System32 \ mematikan.

Di sini Anda dapat menggunakan sakelar -s untuk mematikan sistem, sakelar -r untuk memulai ulang sistem dan sakelar -t untuk menentukan penundaan waktu. Kita dapat mematikannya dengan menuliskan kode berikut

public class Runtime2{  
 public static void main(String args[])throws Exception{  
  Runtime.getRuntime().exec("shutdown -s -t 0");  
 }  
}  

Mematikan Sistem Windows pada Java

Kita dapat mematikan sistem pada windows kita dengan menggunakan kode Java berikut ini

public class Runtime2{  
 public static void main(String args[])throws Exception{  
  Runtime.getRuntime().exec("c:\\Windows\\System32\\shutdown -s -t 0");  
 }  
} 

Merestart Sistem pada Java

Kita dapat restart sistem kita dengan menggunakan kode Java berikut ini

public class Runtime3{  
 public static void main(String args[])throws Exception{  
  Runtime.getRuntime().exec("shutdown -r -t 0");  
 }  
}  

Java Runtime availableProcessors()

Dapat melihat prosesor yang tesedia dengan kode berikut

public class Runtime4{  
 public static void main(String args[])throws Exception{  
  System.out.println(Runtime.getRuntime().availableProcessors());
 }  
} 

Metode Java Runtime freeMemory() dan totalMemory()

Dalam program yang diberikan, setelah membuat 10.000 instance, memori bebas akan lebih kecil dari memori kosong sebelumnya. Tetapi setelah panggilan gc (), Anda akan mendapatkan lebih banyak memori bebas. Kita dapat mengecek free memory dan total memory yang ada saat ini dengan bantuan kode berikut

public class MemoryTest{  
 public static void main(String args[])throws Exception{  
  Runtime r=Runtime.getRuntime();  
  System.out.println("Total Memory: "+r.totalMemory());  
  System.out.println("Free Memory: "+r.freeMemory());  
    
  for(int i=0;i<10000;i++){  
   new MemoryTest();  
  }  
  System.out.println("After creating 10000 instance, Free Memory: "+r.freeMemory());  
  System.gc();  
  System.out.println("After gc(), Free Memory: "+r.freeMemory());  
 }  
}  

Maka akan menghasilkan output berikut

Total Memory: 100139008
Free Memory: 99474824
After creating 10000 instance, Free Memory: 99310552
After gc(), Free Memory: 100182832