THREAD TOPIK Pengertian Thread Dasardasar State Thread dari

THREAD

TOPIK � Pengertian Thread � Dasar-dasar �State Thread dari Thread �Prioritas � Class Thread �Constructor �Constants �Method

TOPIK � Membuat Threads � Menurunkan Class (Extend) Thread � Meng-implementasikan Interface Runnable � Extend vs. Implement � Sinkronisasi � Mengunci Object � Komunikasi Antar Thread (Interthread) � Kemampuan Concurrency

THREADS � Mengapa menggunakan threads? � � Dibutuhkan untuk mengatasi aliran proses Pengertian � � � Merupakan sebuah pengontrol aliran program Untuk lebih mudahnya, bayangkanlah threads sebagai proses yang dieksekusi oleh sebuah program Contoh: � � Operating System Hot. Java web browser

THREADS

STATE DARI THREAD � Sebuah thread memungkinkan untuk memiliki beberapa state : 1. Running � Thread yang sedang dieksekusi � Didalam control dari CPU 2. Ready to run � Siap untuk dieksekusi tetapi belum ada kesempatan untuk melakukannya 3. Resumed � Siap 4. dijalankan setelah diberhentikan sementara atau diblok Suspended � Thread yang berhenti sementara, dan kemudian memperbolehkan CPU untuk menjalankan thread lain bekerja 5. Blocked � Menunggu sebuah resource tersedia atau sebuah event terjadi

PRIORITAS THREAD � � Mengapa menggunakan prioritas? � Menentukan thread mana yang akan menerima control dari CPU dan akan dieksekusi pertama kali Pengertian: � Nilai integer dari angka 1 sampai dengan 10 � Prioritas thread paling tinggi→ semakin besar kesempatan untuk dieksekusi terlebih dahulu � Contoh: �Dua threads siap untuk dijalankan �Thread pertama: prioritas nomor 5, telah dijalankan �Thread kedua: prioritas nomor 10, dijalankan ketika thread pertama sedang dijalankan

PRIORITAS THREAD � Context switch � Terjadi apabila sebagian dari thread telah dikontrol oleh CPU dari thread yang lain � Ketika switch terjadi? �prioritas tertinggi dari thread adalah thread yang siap untuk menerima kontrol dari CPU �Pada saat sebuah thread yang sedang berjalan diambil alih oleh thread yang memiliki prioritas tertinggi � Lebih dari satu prioritas thread yang siap untuk dijalankan � Menentukan prioritas untuk menerima kontrol dari CPU bergantung pada sistem operasi � Windows 95/98/NT: Menggunakan time-sliced dan round-robin � Solaris: Membiarkan CPU untuk mengontrol thread yang lain

CLASS THREAD : CONSTRUCTOR Memiliki delapan constructor Thread Constructors Thread() Membuat sebuah object Thread yang baru. Thread(String name) Membuat sebuah object thread dengan memberikan penamaan yang spesifik. Thread(Runnable target) Membuat sebuah object Thread yang baru berdasar pada object Runnable. Target menyatakan sebuah object dimana method run dipanggil. Thread(Runnable target, String name) Membuat sebuah object Thread yang baru dengan nama yang spesifik dan berdasarkan pada object Runnable.

CLASS THREAD : CONSTANTS Berisi field untuk nilai prioritas Thread Constants public final static int MAX_PRIORITY Nilai prioritas maksimum, 10 public final static int MIN_PRIORITY Nilai prioritas minimum, 1. public final static int NORM_PRIORITY Nilai default prioritas, 5.

CLASS THREAD : METHODS Beberapa method Thread Methods public static Thread current. Thread() Mengembalikan sebuah reference kepada thread yang sedang berjalan. public final String get. Name() Mengembalikan nama dari thread. public final void set. Name(String name) Mengulang pemberian nama thread sesuai dengan argument name. Hal ini dapat menyebabkan Security. Exception. public final int get. Priority() Mengembalikan nilai prioritas yang telah diberikan kepada thread tersebut. public final boolean is. Alive() Menunjukkan bahwa thread tersebut sedang berjalan atau tidak.

CONTOH SEBUAH THREAD 1 2 3 4 5 6 7 8 9 10 11 12 13 14 import javax. swing. *; import java. awt. *; class Count. Down. GUI extends JFrame { JLabel label; Count. Down. GUI(String title) { super(title); label = new JLabel("Start count!"); set. Default. Close. Operation(JFrame. EXIT_ON_CLOSE); get. Content. Pane(). add(new Panel(), order. Layout. WEST); get. Content. Pane(). add(label); set. Size(300, 300); set. Visible(true); } //bersambung. . .

CONTOH SEBUAH THREAD 15 16 17 18 19 20 21 22 23 24 25 26 27 28 void start. Count() { try { for (int i = 10; i > 0; i--) { Thread. sleep(1000); label. set. Text(i + ""); } Thread. sleep(1000); label. set. Text("Count down complete. "); Thread. sleep(1000); } catch (Interrupted. Exception ie) { } label. set. Text(Thread. current. Thread(). to. String()); } //bersambung. . .

CONTOH SEBUAH THREAD 29 { public static void main(String args[]) Count. Down. GUI cdg = 31 new Count. Down. GUI("Count down GUI"); 32 cdg. start. Count(); 33 } 34 } 30

MEMBUAT THREADS �Dua cara dalam membuat threads: �Menurunkan Class Thread �Mengimplementasikan interface Runnable

MEMBUAT TURUNAN CLASS THREAD 1 2 3 4 5 6 7 8 9 10 11 12 13 class Print. Name. Thread extends Thread { Print. Name. Thread(String name) { super(name); start(); //runs the thread once instantiated } public void run() { String name = get. Name(); for (int i = 0; i < 100; i++) { System. out. print(name); } } } //bersambung

Membuat turunan Class Thread 14 class 15 16 17 18 19 20 21 22 23 24 25 } Test. Thread { public static void main(String args[]) { Print. Name. Thread pnt 1 = new Print. Name. Thread("A"); Print. Name. Thread pnt 2 = new Print. Name. Thread("B"); Print. Name. Thread pnt 3 = new Print. Name. Thread("C"); Print. Name. Thread pnt 4 = new Print. Name. Thread("D"); }

Membuat turunan Class Thread �Dapat memodifikasi method main seperti berikut ini: 14. class Test. Thread { 15. public static void main(String args[]) { 16. new Print. Name. Thread("A"); 17. new Print. Name. Thread("B"); 18. new Print. Name. Thread("C"); 19. new Print. Name. Thread("D"); 20. }

Membuat turunan Class Thread �Contoh hasil: AAAAAAAAAAAAAAAAAAAAAABCDABCDABCDABCDABCDABCD ABCDABCDABCDABCDABCDABCDAB CDABCDABCDABCDABCDBCDBCDBCDBCDBCDBCDBCDBCDBCDBCDBCDBCDBCDBCD

MENGIMPLEMENTASIKAN INTERFACE RUNNABLE � Hanya membutuhkan implementasi dari method run � Bayangkanlah bahwa method run adalah method utama dari thread yang diciptakan � Contoh: 1 class Test. Thread { 2 public static void main(String args[]) { 3 new Print. Name. Thread("A"); 4 new Print. Name. Thread("B"); 5 new Print. Name. Thread("C"); 6 new Print. Name. Thread("D"); 7 } 8 } 9 //bersambung. . .

MENGIMPLEMENTASIKAN INTERFACE RUNNABLE 10. class 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. } Print. Name. Thread implements Runnable { Thread thread; Print. Name. Thread(String name) { thread = new Thread(this, name); thread. start(); } public void run() { String name = thread. get. Name(); for (int i = 0; i < 100; i++) { System. out. print(name); } }

EXTEND VS. IMPLEMENT � Memilih salah satu dari kedua cara tersebut bukanlah sebuah permasalahan � Implementasi interface Runnable � Menyebabkan lebih banyak pekerjaan karena kita harus � Mendeklarasikan sebuah object Thread � Memanggil method Thread pada object itu � Class � Anda tetap dapat menjadi turunan dari class lain Menurunkan class Thread � Lebih mudah untuk diimplementasikan � Class Anda tidak dapat menjadi turunan dari class yang lainnya

CONTOH: METHOD JOIN � Menyebabkan thread yang sedang bekerja saat ini menungggu sampai thread yang memanggil method ini selesai dieksekusi � Contoh: 1 class Print. Name. Thread implements Runnable { 2 Thread thread; 3 Print. Name. Thread(String name) { 4 thread = new Thread(this, name); 5 thread. start(); 6 } 7 //bersambung

CONTOH: METHOD JOIN 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public void run() { String name = thread. get. Name(); for (int i = 0; i < 100; i++) { System. out. print(name); } } } class Test. Thread { public static void Print. Name. Thread //bersambung. . . main(String args[]) { pnt 1 = new Print. Name. Thread("A"); pnt 2 = new Print. Name. Thread("B"); pnt 3 = new Print. Name. Thread("C"); pnt 4 = new Print. Name. Thread("D");

CONTOH: METHOD JOIN System. out. println("Running threads. . . "); try { pnt 1. thread. join(); pnt 2. thread. join(); pnt 3. thread. join(); pnt 4. thread. join(); } catch (Interrupted. Exception ie) { } System. out. println("Threads killed. "); 22 23 24 25 26 27 28 29 30 31 32 33 } } //mencoba untuk menghilangkan block catch yang ada

SINKRONISASI �Mengapa menggunakan sinkronisasi threads? �Bagaimanapun juga sebuah thread yang berjalan bersama-sama kadang-kadang membutuhkan resource atau method dari luar �Butuh untuk berkomunikasi satu dengan yang lain sehingga dapat mengetahui status dan aktifitas mereka �Contoh: Permasalahan Produser-Konsumer

SEBUAH CONTOH YANG TIDAK DISINKRONISASI 1 2 3 4 5 6 7 8 9 10 11 class Two. Strings { static void print(String str 1, String str 2) { System. out. print(str 1); try { Thread. sleep(500); } catch (Interrupted. Exception ie) { } System. out. println(str 2); } } //bersambung. . .

SEBUAH CONTOH YANG TIDAK DISINKRONISASI 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class Print. Strings. Thread implements Runnable { Thread thread; String str 1, str 2; Print. Strings. Thread(String str 1, String str 2) { this. str 1 = str 1; this. str 2 = str 2; thread = new Thread(this); thread. start(); } public void run() { Two. Strings. print(str 1, str 2); } } //bersambung. . .

SEBUAH CONTOH YANG TIDAK DISINKRONISASI 26 27 28 29 30 31 32 33 class Test. Thread { public static void main(String args[]) { new Print. Strings. Thread("Hello ", "there. "); new Print. Strings. Thread("How are ", "you? "); new Print. Strings. Thread("Thank you ", "very much!"); } }

SEBUAH CONTOH YANG TIDAK DISINKRONISASI �Contoh hasil: Hello How are Thank you there. you? very much!

SINKRONISASI: MENGUNCI SEBUAH OBJECT � Mengunci sebuah object: � Untuk memastikan bahwa hanya satu thread yang mendapatkan hak akses kedalam method tertentu � Java memperbolehkan penguncian terhadap sebuah object termasuk method-nya dengan menggunakan monitor �Object tersebut akan menjalankan sebuah monitor implicit pada saat object dari method sinkronisasi dipanggil �Sekali object tersebut dimonitor, monitor tersebut akan memastikan bahwa tidak ada thread yang akan mengakses object yang sama

SINKRONISASI: MENGUNCI SEBUAH OBJECT �Sinkronisasi sebuah method: �Menggunakan keyword synchronized �Dapat menjadi header dari pendefinisian method �Dapat mensinkronisasi object dimana method tersebut menjadi anggota dari synchronized (<object>) { //statements yang akan disinkronisasikan }

CONTOH SYNCHRONIZED PERTAMA 1 2 3 4 5 6 7 8 9 10 11 12 class Two. Strings { synchronized static void print(String str 1, String str 2) { System. out. print(str 1); try { Thread. sleep(500); } catch (Interrupted. Exception ie) { } System. out. println(str 2); } } //bersambung. . .

CONTOH SYNCHRONIZED PERTAMA 13 14 15 16 17 18 19 20 21 22 23 24 25 26 class Print. Strings. Thread implements Runnable { Thread thread; String str 1, str 2; Print. Strings. Thread(String str 1, String str 2) { this. str 1 = str 1; this. str 2 = str 2; thread = new Thread(this); thread. start(); } public void run() { Two. Strings. print(str 1, str 2); } } //bersambung. . .

27 28 29 30 31 32 33 34 CONTOH SYNCHRONIZED PERTAMA class Test. Thread { public static void main(String args[]) { new Print. Strings. Thread("Hello ", "there. "); new Print. Strings. Thread("How are ", "you? "); new Print. Strings. Thread("Thank you ", "very much!"); } }

CONTOH SYNCHRONIZED PERTAMA �Contoh Hasil: Hello there. How are you? Thank you very much!

CONTOH SYNCHRONIZED KEDUA 1 2 3 4 5 6 7 8 9 10 11 class Two. Strings { static void print(String str 1, String str 2) { System. out. print(str 1); try { Thread. sleep(500); } catch (Interrupted. Exception ie) { } System. out. println(str 2); } } //bersambung. . .

CONTOH SYNCHRONIZED KEDUA 12 13 14 15 16 17 18 19 20 21 22 23 24 class Print. Strings. Thread implements Runnable { Thread thread; String str 1, str 2; Two. Strings ts; Print. Strings. Thread(String str 1, String str 2, Two. Strings ts) { this. str 1 = str 1; this. str 2 = str 2; this. ts = ts; thread = new Thread(this); thread. start(); } //bersambung. . .

CONTOH SYNCHRONIZED KEDUA 25 26 27 28 29 30 31 32 33 34 35 36 37 38 public void run() { synchronized (ts) { ts. print(str 1, str 2); } } } class Test. Thread { public static void main(String args[]) { Two. Strings ts = new Two. Strings(); new Print. Strings. Thread("Hello ", "there. ", ts); new Print. Strings. Thread("How are ", "you? ", ts); new Print. Strings. Thread("Thank you ", "very much!", ts); }}

KOMUNIKASI ANTAR THREAD: METHODS Methods untuk komunikasi Interthread public final void wait() Menyebabkan thread ini menunggu sampai thread yang lain memanggil notify atau notify. All method dari object ini. Hal ini dapat menyebabkan Interrupted. Exception. public final void notify() Membangunkan thread yang telah memanggil method wait dari object yang sama. public final void notify. All() Membangunkan semua thread yang telah memanggil method wait dari object yang sama.

KOMUNIKASI ANTAR THREAD

CONTOH PRODUSEN-KONSUMEN 1 2 3 4 5 6 7 8 9 10 11 12 class Shared. Data { int data; synchronized void set(int value) { System. out. println("Generate " + value); data = value; } synchronized int get() { System. out. println("Get " + data); return data; } } //bersambung. . .

CONTOH PRODUSEN-KONSUMEN 13 14 15 16 17 18 19 20 21 22 23 24 25 class Producer implements Runnable { Shared. Data sd; Producer(Shared. Data sd) { this. sd = sd; new Thread(this, "Producer"). start(); } public void run() { for (int i = 0; i < 10; i++) { sd. set((int)(Math. random()*100)); } } } //bersambung. . .

CONTOH PRODUSEN-KONSUMEN 26 27 28 29 30 31 32 33 34 35 36 37 38 class Consumer implements Runnable { Shared. Data sd; Consumer(Shared. Data sd) { this. sd = sd; new Thread(this, "Consumer"). start(); } public void run() { for (int i = 0; i < 10 ; i++) { sd. get(); } } } //bersambung. . .

CONTOH PRODUSEN-KONSUMEN 39 class Test. Producer. Consumer { 40 public static void main(String args[]) 41 throws Exception { 42 Shared. Data sd = new Shared. Data(); 43 new Producer(sd); 44 new Consumer(sd); 45 } 46 }

CONTOH PRODUSEN-KONSUMEN �Contoh hasil: Generate Get 65 Generate Get 23 Generate Get 49 8 45 52 65 23 Get 35 Generate 39 Get 39 Generate 85 Get 85 Generate 35 Get 35 49 Get 35

CONTOH PRODUSEN-KONSUMEN YANG TELAH DIPERBAIKI 1 2 3 4 5 6 7 8 9 10 11 class Shared. Data { int data; boolean value. Set = false; synchronized void set(int value) { if (value. Set) { //hanya dihasilkan jika mempumyai sebuah nilai try { wait(); } catch (Interrupted. Exception ie) { } } //bersambung. . .

CONTOH PRODUSEN-KONSUMEN YANG TELAH DIPERBAIKI System. out. println("Generate " + value); 13 data = value; 14 value. Set = true; 15 notify(); 16 } 17 //bersambung. . . 12

CONTOH PRODUSEN-KONSUMEN YANG TELAH DIPERBAIKI 18 19 20 21 22 23 { 24 synchronized int get() { if (!value. Set) { //producer belum memiliki suatu nilai try { wait(); } catch (Interrupted. Exception ie) } } 26 //bersambung. . . 25

CONTOH PRODUSEN-KONSUMEN YANG TELAH DIPERBAIKI System. out. println("Get " + data); value. Set = false; notify(); return data; 26 27 28 29 30 } 31 } 32 /* Bagian kode tertentu tidak berubah. */

CONTOH PRODUSEN-KONSUMEN �Contoh hasil: Generate Get 76 Generate Get 25 Generate Get 34 Generate Get 84 Generate Get 48 76 Get 29 Generate 26 Get 26 25 34 Generate 86 Get 86 Generate 65 Get 65 Generate 38 84 48 Get 38 Generate 46 Get 46

KEMAMPUAN CONCURRENCY �Dirilisi pada Java 2 SE 5. 0 �Dapat ditemukakn pada paket java. util. concurrent �Interface �Executor �Callable

INTERFACE EXECUTOR �(BEFORE) Mengeksekusi Tugas-tugas Runnable: new Thread(<a. Runnable. Object>). start() ; �(AFTER) Mengeksekusi Tugas-tugas Runnable : <an. Executor. Object>. execute(<a. Runna ble. Object>);

INTERFACE EXECUTOR �Permasalahan �Membuat dengan teknik yang lama: Thread sangat mahal. �Membutuhkan pengaturan dan penumpukan di suatu tempat �Dapat mengakibatkan error pada memori �Solusi: � Menggunakan � pooling thread Mengimplementasikan sebuah skema thread pooling dengan desain yang baik, tidaklah mudah dilakukan �Kesulitan untuk membatalkan atau mematikan sebuah thread

INTERFACE EXECUTOR � Solusi untuk permasalahan dengan teknik yang lama: � Menggunakan interface Executor �Decoupling task submission dari mechanic mengenai bagaimana setiap tugas dijalankan � Mengggunakan interface Executor : Executor <executor. Name> = <an. Executor. Object>; <executor. Name>. execute(new <Runnable. Task 1>()); <executor. Name>. execute(new <Runnable. Task 2>()); . . .

INTERFACE EXECUTOR � Membuat sebuah object dari tipe Executor: � Tidak dapat di-instantiate � Dapat membuat sebuah class yang mengimplementasikan interface ini � Dapat menggunakan factory method yang telah disediakan class Executor �Class Executors juga menyediakan factory method untuk me-manage thread pool sederhana

EXECUTORS FACTORY METHODS Factory Method dari class Executor public static Executor. Service new. Cached. Thread. Pool() Menciptakan sebuah pool thread yang akan menciptakan thread sesuai yang dibutuhkan, atau ia akan menggunakan kembali thread yang telah dibangun sebelumnya, apabila tersedia. Sebuah method overloading, juga akan menggunakan object Thread. Factory sebagai argument. public static Executor. Service new. Fixed. Thread. Pool(int n. Threads) Menciptakan sebuah pool thread yang dapat digunakan kembali untuk membetulkan sebuah thread yang berada didalam antrian yang tidak teratur. Sebuah overloading method, akan menggunakan object Thread. Factory sebagai tambahan parameter. public static Scheduled. Executor. Service new. Scheduled. Thread. Pool(int core. Pool. Size) Menciptakan sebuah pool thread yang akan menjadwalkan command yang akan berjalan setelah diberikan sebuah delay, atau untuk mengeksekusi secara periodic. Sebuah overloading method, akan menggunakan object Thread. Factory sebagai tambahan parameter. public static Executor. Service new. Single. Thread. Executor() Menciptakan sebuah Executor yang digunakan sebagai satu-nya pelaksana dari sebuah antrian thread yang tidak teratur. Creates an Executor that uses a single worker thread operating off an unbounded queue. Sebuah overloading method, juga akan menggunakan object Thread. Factory sebagai tambahan parameter. public static Scheduled. Executor. Service new. Single. Thread. Scheduled. Executor() Menciptakan sebuah Executor thread yang akan menjadwalkan command untuk dijalankan setelah delay tertentu, atau dieksekusi secara periodic. Sebuah overloading method, juga akan menggunakan object Thread. Factory sebagai tambahan parameter

INTERFACE EXECUTOR �Mengontrol eksekusi dan penyelesaian dari tugas-tugas Runnable �Memberhentikan threads: executor. shutdown();

INTERFACE CALLABLE �Mengingat �Dua kembali: cara dalam membuat threads: �Menurunkan (Extend) class Thread �Mengimplementasikan (implement) sebuah interface Runnable �Harus menjalankan method run public void run() //no throws clause �Interface �interface Callable Runnable tanpa kelemahan-

INTERFACE CALLABLE � (BEFORE) Mendapatkan hasil dari sebuah tugas Runnable: public My. Runnable implements Runnable { private int result = 0; public void run() {. . . result = some. Value; } /* hasil attribut terlindung dari perubahan dari kode lain yang mengakses class ini*/ public int get. Result() { return result; } }

INTERFACE CALLABLE �(AFTER) Mendapatkan hasil dari sebuah tugas Runnable : import java. util. concurrent. *; public class My. Callable implements Callable { public Integer call() throws java. io. IOException {. . . return some. Value; }

INTERFACE CALLABLE �Method call V call throws Exception dimana V adalah sebuah tipe generic. �Fitur-fitur �J 2 SE concurrency yang lain 5. 0 API documentation

RINGKASAN �Threads �Pengertian Thread �State dari Thread �Running �Ready to run �Resumed �Suspended �Blocked �Prioritas �Nilai integer dari angka 1 sampai dengan 10

� RINGKASAN Class Thread � Constructor � Constants �MAX_PRIORITY ● �MIN_PRIORITY �NORM_PRIORITY � Methods �current. Thread() �get. Name() �set. Name(String �get. Priority() name) join([long millis, [int nanos]]) ● sleep(long millis) ● run() ● start()

RINGKASAN � Membuat Threads � Menurunkan Class Thread � Mengimplementasikan Interface Runnable � Extend vs. Implement � Sinkronisasi � Mengunci sebuah Object � Keyword synchronized �Method �Object header

RINGKASAN � Komunikasi Antar Thread (Interthread) � Methods �wait �notify. All � Kemampuan Concurrency � Interface Executor �Executors � Interface factory methods Callable