java2
Sebelumnya, kita telah membahas tentang pengenalan thread, dan process. Sekarang kita akan lanjutkan pembahasan, dengan mempelajari tentang bagaimana cara membuat sebuah thread baru. Dalam Java ada dua cara untuk membuat sebuah thread baru :
Cara pertama yaitu, Melakukan extend sebuah subclass dari superclass Thread kemudian meng-override method run() untuk menentukan alur ekseskusi seperti apa yang akan dilaksanakan ketika ketika thread dijalankan. Setelah itu buat sebuah instansi dan panggil method start(, maka JRE akan memanggil method run() pada thread baru yang kita buat.
Sedangkan cara kedua adalah membuat sebuah class yang kemudian men-implement interface Runnable dan menyediakan implementasi terhadap method abstract run() yang akan menentukan program yang akan berjalan ketika thread mulai aktif. Setelah itu buat sebuah instansi Thread baru menggunakan constructor dengan sebuah object Runnable dan panggil method start() yang akan membuat JRE memanggil method run() pada sebuah thread baru.
Cara kedua ini digunakan, karena java tidak mendukung pewarisan banyak. Jika sebuah class telah meng- extends dari superclass yang lain, maka kita tidak bisa lagi mengenxtend dari superclass Thread sebagaimana cara 1, solusinya adalah, kita bisa mengimplement interface Runnable. Cara kedua ini juga digunakan untuk menyediakan kompabilitas dengan JDK 1.1. Yang perlu diingat adalah bahwa class Thread class sendiri telah mengimplement interface Runnable .
Sebagaimana yang telah disebutkan, Method run() menentukan program apa yang akan dijalankan pada thread dan memberikan thread sesuatu yang harus dilakukan. Kita tidak bisa memanggil method run() langsung dari program secara eksplisit. Namun dengan membuat sebuah instansi dari Thread lalu memanggil method start(). Method start() inilah yang pada gilirannya akan memanggil method run() pada thread baru.
Interface Runnable
Interface java.lang.Runnable mendeklarasikan sebuah method abstract yaitu method run(), yang digunakan untuk menentukan apa yang harus dilakukan thread, ketika thread baru dijalankan:
?
1
public void run();
Class Thread
Class java.lang.Thread memiliki constructor berikut:
?
1
2
3
4
public Thread();
public Thread(String threadName);
public Thread(Runnable target);
public Thread(Runnable target, String threadName);
Dua constructor pertama digunakan untuk membuat sebuah thread dengan menjadikan subclass dari class Thread. Dua constructor berikutnya, digunakan untuk membuat sebuah thread dengan sebuah instansi dari class yang meng-implement interface Runnable.
Class Thread mengimplementkan interface Runnable seperti ditunjukan pada diagram berikut.
Multithread_ThreadRunnable
Jika sebuah thread dibentuk dari mengekstend class Thread, maka method start() akan memanggil method run() pada extended class. Pada sisi lain, jika thread dibentuk dengan menyediakan sebuah object Runnable kepada contructor Thread, maka method start() akan memanggil method run() dari object Runnable .
Membuat sebuah Thread baru dengan cara menjadi sub-class dari Superclass Thread
Berikut adalah cara bagaimana kita membuat dan menjalankan sebuah thread baru dengan mengextend class Thread:
Tentukan sebuah subclass yang mengekstends dari superclass Thread.
Di dalam subclass, override method run() untuk menentukan operasi thread (dan menyediakan implementasi lain seperti constructor, variable dan method).
Sebuah class client membuat instansi dari class ini. Instansi ini disebut dengan Runnable object (karena class Thread itu sendiri mengimplementkan interface Runnable ).
Class client memanggil method start() dari object Runnable. Hasilnya dua thread akan berjalan secara bersamaan, pertama thread lanjutan setelah memanggil method start(), dan sebuah thread baru yang mengeksekusi method run() pada object Runnable.
Bingung ya, hm. oke kita berikan contohnya sebagai berikut,
?
1
2
3
4
5
6
7
8
9
class MyThread extends Thread {
// override method run()
@Override
public void run() {
// program yang dijalankan thread baru disini
}
// constructor, dan method atau variabel lain
......
}
?
1
2
3
4
5
6
7
8
9
10
11
12
public class Client {
public static void main(String[] args) {
......
// Start a new thread
MyThread t1 = new MyThread();
t1.start(); // Called back run()
......
// Start another thread
new MyThread().start();
......
}
}
Sering sebuah class inner (class di dalam class) yang digunakan daripada sebuah class biasa. ini bisa dilakukan untuk tujuan agar bisa dibaca dan menyediakan akses kepada variabel dan method private dari class outer, seperti contoh sebagai berikut :
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Client {
......
public Client() {
Thread t = new Thread() { // membuat sebuah class inner yang mengekstends Thread
@Override
public void run() {
// flow program thread disini
// karena inner class, jadi bisa mengakses outer class
}
};
t.start();
...
// bisa juga memanggil inner class dengan cara ini
new MyThread().start();
}
// Mendeklarasikan inner class yang mengekstend Thread
class MyThread extends Thread {
public void run() {
// flow program thread
// bisa mengakses variabel dan method private class outer
}
}
}
Sekarang kita akan buat contohnya program sederhana yang menggunakan thread
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MyThread extends Thread {
private String name;
public MyThread(String name) { // constructor
this.name = name;
}
// Override the run() method to specify the thread's running behavior
@Override
public void run() {
for (int i = 1; i <= 5; ++i) {
System.out.println(name + ": " + i);
yield();
}
}
}
?
1
2
3
4
5
6
7
8
9
10
11
12
public class TestMyThread {
public static void main(String[] args) {
Thread[] threads = {
new MyThread("Thread 1"),
new MyThread("Thread 2"),
new MyThread("Thread 3")
};
for (Thread t : threads) {
t.start();
}
}
}
Untuk menguji class yang mengalokasikan dan menjalankan tiga thread baru. Maka keluaran sebagai berikut: Sebuah class yang dipanggil MyThead dibuat dengan mengextend class Thread dan mengoverride method run(). Sebuah constructor ditentukan mengambil string sebagai nama. Method run() mencetak 1 hingga 5, dan memanggil yield() untuk menghasilkan kendali thread kepada thread lain setelah mencetak pada tiap bilangan.
Thread 1: 1
Thread 3: 1
Thread 1: 2
Thread 2: 1
Thread 1: 3
Thread 3: 2
Thread 2: 2
Thread 3: 3
Thread 1: 4
Thread 1: 5
Thread 3: 4
Thread 3: 5
Thread 2: 3
Thread 2: 4
Thread 2: 5
Perhatikan bahwa keluaran program tersebut tak tentu (run yang berbeda kemungkinan akan menghasilkan keluaran yang berbeda), karena kita tidak memiliki kontrol penuh pada bagaimana sebuah thread dieksekusi.
Membuat Thread baru dengan Meng-implement interface Runnable.
Untuk membuat dan menjalankan thread baru dengan implement interface Runnable maka caranya adalah sebagai berikut:
Tentukan sebuah class yang akan mengimplement interface Runnable.
Di dalam class, sediakan implementasi dari method abstract run() untuk menentukan operasi thread ( dan menyediakan implementasi lain seperti constructor, variabel dan method).
Sebuah client membuah sebuah instansi dari class baru ini. Instansi tersebut dipanggil sebagai object Runnable .
Class client kemudian membangun object Thread baru dengan object Runnable sebagai argumennya pada constructor dan kemudian memanggil method start(. Method start akan memanggil method run() pada object Runnable (bukan class Thread ).
?
1
2
3
4
5
6
7
8
9
class MyRunnable extends SomeClass implements Runnable {
// provide implementation to abstract method run()
@Override
public void run() {
// Thread's running behavior
}
......
// constructors, other variables and methods
}
?
1
2
3
4
5
6
public class Client {
......
Thread t = new Thread(new MyRunnable());
t.start();
...
}
Lagi, sebuah class inner sering digunakan untuk kepentingan kemudahbacaaan dan untuk menyediakan akses ke variabel dan method private dari class outer.
?
1
2
3
4
5
6
7
Thread t = new Thread(new Runnable() { // Create an anonymous inner class that implements Runnable interface
public void run() {
// Thread's running behavior
// Can access the private variables and methods of the outer class
}
});
t.start();
Method- method pada class Thread
Method – method yang tersedia di class Thread termasuk:
?
1
public void start()
Memulai sebuah thread baru. JRE akan memanggil method run() dari class ini. Thread terakhir masih akan berlanjut.
?
1
public void run()
untuk menentukan alur eksekusi dari thread baru. Ketika method run() selesei dijalankan, maka thread akan berhenti.
?
1
2
3
public static sleep(long millis) throws InterruptedException
public static sleep(long millis, int nanos) throws InterruptedException
public void interrupt()
Menghentikam thread dan mengendalikan thread lain pada beberapa milliseconds (atau nanoseconds). Method sleep() bersifat thread-safe dan tidak melepaskan pemantauan. Kita bisa membangunkan thread yang tertidur sebelum waktu yang ditentukan dengan memanggil method interrupt(). Thread yang telah terbangun akan memberikan error InterruptedException dan mengeksekusi penanganan InterruptedException sebelum melanjutkan operasinya. ini adalah sebuah method static (yang tidak memerlukan sebuah instansi) dan biasanya digunakan untuk menghentikan sementara thread terkini(melalui Thread.sleep()) sehingga thread yang lain mempunya kesempatan untuk mengeksekusi. Ini biasanya juga menyediakan penundaaan pada beberapa apalikasi. Seperti berikut:
?
1
2
3
4
5
try {
// Suspend the current thread and give other threads a chance to run
// Also provide the necessary delay
Thread.sleep(100); // milliseconds
} catch (InterruptedException ex) {}
public static void yield(): Memberi petunjuk untuk penjadwalan bahwa thread saat ini bersedia untuk memberikan penggunaannya terkini pada prosesor untuk memungkinkan thread lain untuk berjalan. Penjadwalan bagaimanapun bebas untuk mengabaikan petunjuk ini. Method ini jarang digunakan
public boolean isAlive(): Memberikan Return false jika thread baru atau mati. Memberikan Return true jika thread ”runnable” atau “not runnable”.
public void setPriority(int p): mengatur tingkat prioritas dari thread
Method stop(), suspend(), dan resume() sudah deprecated (tidak digunakan) di JDK 1.4, karena ia tidak thread-safe, karena membangkitkan pelepasan pemantauan. Lihat dokumentasi JDK API untuk lebih lengkapnya
Selamat mencoba, have a nice coding
0 komentar:
Posting Komentar