LAPORAN PRAKTIKUM SISTEM OPERASI THREAD

Oleh :

Nama NIM

: Anang Ashari Romdhoni : M0510005

INFORMATIKA FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM UNIVERSITAS SEBELAS MARET 2011

SOURCE CODE DAN ANALISIS

1. Contoh 1 Source code :
package contoh1; import java.awt.Canvas; //import data dari package java dalam class awt. import java.awt.Dimension; //import data dari package java dalam class awt. import java.awt.Graphics; //import data dari package java dalam class awt.

public class Ball { //class Ball untuk mengatur bola private Canvas box; private int x=0; //variabel x bertipe int private untuk menentukan letak awal koordinat bola di // x=0 (atas) private int y=0; // variabel y bertipe int private untuk menentukan letak awal koordinat bola di // y=0 (kiri) private static final int xsize=10; //menentukan diameter x bola yaitu 10 private static final int ysize=10; //menentukan diameter y bola yaitu 10 private int dx=2; //menentukan letak jatuh awal bola di koordinat x=2 private int dy=2; //menentukan letak jatuh awal bola di koordinat y=2 public Ball(Canvas c){ // konstruktor Ball dengan parameter Canvas c this.box = c; //melakukan pengambilan value dari c ke box. } public void draw(){ //method draw Graphics g = this.box.getGraphics(); // membuat objek baru bernama g g.fillOval(x,y,xsize,ysize); //memanggil method fillOval() dari objek g g.dispose(); // memanggil method dispose() dari objek g } public void move(){ //method move bertipe void Graphics g = this.box.getGraphics(); // membuat objek bernama g bertipe Graphics g.setXORMode(box.getBackground()); //memanggil method setXORMode() dari objek g g.fillOval(x,y,xsize,ysize); //memanggil method fillOval() dari objek g x += dx; //pergerakan ball dengan posisi x = x+ dx y +=dy; //pergerakan ball dengan posisi y = y+ dy Dimension d = box.size(); //membuat objek baru d dari Dimension. if (x<0){ x=0;dx = -dx; }

if (x+xsize >= d.width){x=d.width-xsize;dx=-dx;} if (y<0){y=0;dy=-dy;} if (y+ysize >= d.height){y=d.height-ysize;dy=-dy;} g.fillOval(x,y,xsize,ysize); //memanggil method fillOval() dari objek g g.dispose(); //memanggil method dispose() dari objek g }

public void bounce(){// method bounce bertipe void. draw();// memanggil method Draw() for(int i=1;i<=5000;i++){ //melakukan pengulangan nilai i dari 1 sampai 5000, dengan // increment +1 move(); //memanggil method move() try{ //mencoba menjalankan perintah Thread.sleep(5); Jika tidak ada pengecualian, //maka catch diabaikan Thread.sleep(5); } catch (InterruptedException e){} //jika ada pengecualian 'InterruptedException e' akan ditangkap catch// } } }

package contoh1; import java.awt.*; //import data dari package java dalam class awt. public class Bounce extends Frame{// class Bounce turunan dari class Frame private Canvas canvas; public Bounce(){//konstruktor Bounce setTitle("Bounce"); //menampilkan nama frame yang bernama Bounce canvas = new Canvas(); add("Center",canvas); //mengatur letak canvas berada di tengah Panel p = new Panel(); //membuat object baru bernama p p.add(new Button("Start")); //menambah panel bernama Start p.add(new Button("Close")); //menambah panel bernama Close add("South",p); //mengatur objek p berada di bawah } public boolean handleEvent(Event evt){ //method boolean

if (evt.id==Event.WINDOW_DESTROY) System.exit(0); return super.handleEvent(evt);//mendeklarasi fungsi jika frame dikenai event } public boolean action(Event evt, Object arg){ if (arg.equals("Start")){ Ball b = new Ball(canvas); //membuat objek b bertipe Ball b.bounce(); //memanggil method bounce() dari objek b } else if(arg.equals("Close")){ System.exit(0); } else { return super.action(evt,arg); } return true; } public static void main(String[] args) { // create main fungtion // TODO Auto-generated method stub Frame f = new Bounce(); // membuat objek baru bernama f f.resize(300,200); // menentukan ukuran windows f f.show(); // memanggil fungsi show dari objek f } }

Analisis : Pada source code diatas, terdapat 5 method. Secara keseluruhan, class Ball digunakan untuk mengatur gerak bola, ukuran frame dan arah gerak bola. Sesuai source code diatas, bola berdiameter 10, dengan posisi awal bola di x dan y adalah 0, dan posisi awal jatuh bola di koordinat (2,2) dan seterusnya. Kemudian pada kelas bounce digunakan untuk mengatur Frame dan menjalankan program saat dieksekusi.. Saat program dijalankan, maka user harus memilih start atau close. Jika memilih start maka program akan dijalankan lebih lanjut namun jika tidak maka program akan keluar. Saat program dijalankan makan program membuat objek baru bernama f dari Frame kemudian menentukan ukuran windows lalu f memanggil method show.

Selanjutnya program menjalankan method draw kemudian dilanjutkan dengan proses for dengan perulangan 1 sampai 5000 dengan setiap perulangan mengalami increment nilai i dan memanggil method move. Namun sekali proses dijalankan, tidak dapat diganggu lagi karena terdapat fungsi try dan catch yang akan melakukan exetionis penghentian proses, sehingga proses tidak dapat dihentikan, seperti sifat single thread yang tidak bisa diinterupsi. Untuk keluar dari program harus menunggu hingga program selesai di eksekusi.

2. Contoh 2 Cara 1 : Membuat class denga menurunkan dari class Thread. Source Code :
package contoh2; public class PrintNameThread extends Thread{//class PrintNameThread turunan dari class //Thread PrintNameThread(String name) { //konstruktor dengan parameter bertipe String name super(name); //memanggil konstruktor dari kelas Thread dengan parameter name start();//memanggil method start } @Override public void run() {// method run yang meng-override dari java.lang.Thread String name = getName();//mengambil karakter yang disimpan dalam variabel name for (int i = 0; i < 100; i++) {//melakukan perulangan dari 1 sampai 100 dengan increment +1 System.out.print(name);//mencetak isi dari name } } } package contoh2; public class TestThread { public static void main(String args[]) { PrintNameThread pnt1 = new PrintNameThread("A"); //membuat object baru bernama pnt1 dengan parameter A PrintNameThread pnt2 = new PrintNameThread("B"); //membuat object baru bernama pnt2 dengan parameter B PrintNameThread pnt3 = new PrintNameThread("C");

//membuat object baru bernama pnt3 dengan parameter C PrintNameThread pnt4 = new PrintNameThread("D"); //membuat object baru bernama pnt4 dengan parameter D } }

Analisis : Program saat pertama kali dijalankan membuat object baru bernama pnt1, pnt2, pnt3 dan pnt4 dengan parameter masing-masing A, B, C, dan D. Kemudian program menuju class PrintName lalu menjalankan konstruktor PrintName Thread yang didalamnya terdapat super(name); dan start(); untuk memanggil konstruktor dari kelas thread dan memanggil method start. Setelah itu, pada method run akan dilakukan perulangan sebanyak 100 kali dan di setiap perulangan karakter dari variable name akan dtampilkan di layar. Program akan mencetak karakter dari A sampai D, proses berjalan sangat cepat sehingga program tampak seperti berjalan terus atau searah namun sebenarnya program berjalan bergantian sehingga terkadang hasil output A sampai D tidak berurutan. Proses seperti ini seperti konsep thread yang merupakan proses ringan. Thread berjalan bergantian dan saling menginterupsi agar terjadi pergantian pergantian proses sehingga waktu tunggunya tidak terlalu lama.

Cara 2 : dengan mengimplementasikan interface runnable Source Code :

package contoh2cara2;// mendeklarasikan class yang mengimplementasikan interface Runnable public class PrintNameThread implements Runnable{ Thread thread; PrintNameThread(String name) { thread = new Thread(this, name); thread.start(); } //konstruktor dengan parameter name bertipe String //membuat thread baru bernama thread //memulai untuk mengeksekusi thread

@Override

public void run() { java.lang.Thread

// mendeklarasikan method run yang meng-override dari

String name = thread.getName(); name for (int i = 0; i < 100; i++) { System.out.print(name); } } }

//mengambil karakter yang disimpan dalam variabel

//melakukan perulangan sampai 100 kali //mencetak isi dari name

package contoh2cara2; public class TestThread { public static void main(String args[]) { PrintNameThread pnt1 = new PrintNameThread("A"); //membuat object baru bernama pnt1 dengan nilai parameter A PrintNameThread pnt2 = new PrintNameThread("B"); //membuat object baru bernama pnt2 dengan nilai parameter B PrintNameThread pnt3 = new PrintNameThread("C"); //membuat object baru bernama pnt3 dengan nilai parameter C PrintNameThread pnt4 = new PrintNameThread("D"); //membuat object baru bernama pnt4 dengan nilai parameter D } }

Analisis Program saat pertama kali dijalankan membuat object baru bernama pnt1, pnt2, pnt3 dan pnt4 dengan parameter masing-masing A, B, C, dan D. Kemudian program menuju class PrintName yang mengimplementasikan interface Runnable lalu menjalankan konstruktor PrintName Thread yang didalamnya membuat thread baru bernama thread dan mulai mengeksekusi thread tersebut dengan instruksi thread.start();. Setelah itu menuju ke metode run() yang didalam method run akan dilakukan perulangan sebanyak 100 kali dan di setiap perulangannya akan ditampilkan isi dari perintah name. Thread berakhir ketika metode run() berakhir.

Konsep diatas menggunakan konsep multithread yaitu suatu proses dapat diinterupsi oleh proses lain yang berdasarkan algoritma penjadwalan yang digunakan mungkin lebih tinggi derajatnya atau memiliki kode akses yang lebih tinggi dari proses yang sedang dieksekusi.

3. Contoh 3 Source Code :

package contoh3; import java.awt.Canvas; import java.awt.Dimension; import java.awt.Graphics;

public class Ball extends Thread { private Canvas box; private int x=0; //menentukan letak awal koordinat bola di x=0 (atas) private int y=0; //menentukan letak awal koordinat bola di y=0 (kiri) private static final int xsize=10; //menentukan diameter x bola adalah 10 private static final int ysize=10; //menentukan diameter y bola adalah 10 private int dx=2; //menentukan letak jatuh awal bola di koordinat x=2 private int dy=2; //menentukan letak jatuh awal bola di koordinat y=2 public Ball(Canvas c){ // mendeklarasikan konstruktor dengan parameter c this.box = c; //melakukan pengambilan value dari c ke box. }

/* mendeklarasikan method draw yang menjalankan method getGraphics(), dispose() dan fillOval() dari objek Graphics*/ public void draw(){ Graphics g = this.box.getGraphics(); // membuat objek baru bernama g g.fillOval(x,y,xsize,ysize); //memanggil method fillOval() dari objek g g.dispose(); // memanggil method dispose() dari objek g } // mengatur arah gerak bola public void move(){ // mendeklarasikan method move bertipe void Graphics g = this.box.getGraphics(); // membuat objek g bertipe Graphics g.setXORMode(box.getBackground()); //// memanggil method setXORMode() dari objek g

g.fillOval(x,y,xsize,ysize); // memanggil method fillOval() dari objek g x += dx; // melakukan moving ball dengan posisi x = x+ dx y +=dy; // melakukan moving ball dengan posisi y = y+ dy // melakukan manipulasi moving dengan dimension. Dimension d = box.size(); // membuat objek baru d dengan sifat Dimension. if (x<0){ x=0;dx = -dx; } if (x+xsize >= d.width){x=d.width-xsize;dx=-dx;} if (y<0){y=0;dy=-dy;} if (y+ysize >= d.height){y=d.height-ysize;dy=-dy;} g.fillOval(x,y,xsize,ysize); //memanggil method fillOval() dari objek g g.dispose(); // memanggil method dispose() dari objek g }

public void run(){ // deklarasikan method run bertipe void. draw(); // memanggil method Draw() for(int i=1;i<=1000;i++){ //melakukan looping nilai i dari 1 sampai 1000 move(); // memanggil method move() try{ //mencoba menjalankan perintah Thread.sleep(5); Jika tidak ada pengecualian, maka catch diabaikan Thread.sleep(5); } catch (InterruptedException e){}//jika ada pengecualian 'InterruptedException e' akan // ditangkap catch } } }

4. Contoh 4
Source Code : package contoh4; public class TwoString { static void print(String str1, String str2) { //konstruktor dengan parameter str1 dan str2 bertipe String System.out.print(str1); //mencetak isi str1 try { //mencoba menjalankan perintah Thread.sleep(5); Jika tidak ada pengecualian, maka catch //diabaikan

Thread.sleep(500); } catch (InterruptedException ie) { } //jika ada pengecualian 'InterruptedException e' akan ditangkap catch System.out.println(str2);//mencetak isi str2 } }

package contoh4; // mendeklarasikan class yang mengimplementasikan semua method Runnable public class PrintStringsThread implements Runnable { Thread thread; String str1, str2;

//konstruktor dengan parameter str1 dan str2 yang bertipe String PrintStringsThread(String str1, String str2) { this.str1 = str1; this.str2 = str2; thread = new Thread(this);//membuat thread baru bernama thread thread.start(); //memulai untuk mengeksekusi thread } public void run() { //method run TwoString.print(str1, str2); //memanggil method print dengan parameter str1 dan str2 dari class TwoString } }

package contoh4; public class TestThread { public static void main(String args[]) { new PrintStringsThread("Hello ", "there."); new PrintStringsThread("How are ", "you?"); new PrintStringsThread("Thank you ","very much!"); } }

Analisis :

Pada source code diatas, membuat konstruktor baru yang diisi dengan parameter lalu mengaksesnya didalam class PrintStringThread yang

mengimplementasikan Runnable pada konstruktor PrintStringThread diaman nilai parameter akan menjadi nilai str1 dan str2. Setelah itu program akan mengeksekusi thread dengan instruksi thread,start(); dan akan menuju void run() untuk menjalankan thread yang didalamnya terdapat TwoString.print(str1, str2); yang berarti memanggil method print dengan parameter str1 dan str2 dari class TwoString. Pada class TwoString akan mencetak isi str1 dan dengan try-catch program akan mencoba menjalankan perintah Thread.sleep(5); Jika tidak ada pengecualian, maka catch diabaikan namun jika ada pengecualian 'InterruptedException e' akan ditangkap catch. Setelah itu program akan mencetak isi str2. Saat program selesai dieksekusi akan menghasilkan output yang tidak beraturan dan terkadang hasilnya akan berbeda dengan output sebelumnya. Hal ini dikarenakan program berjalan bergantian dan saling menginterupsi agar terjadi

pergantian pergantian proses agar waktu tunggunya tidak terlalu lama karena itu hasil output tidak berututan.

5. Contoh 5
Source Code : package contoh5; public class TwoStrings { synchronized static void print(String str1, String str2) { konstruktor dengan parameter str1 dan str2 bertipe String dan disinkronisasikan System.out.print(str1); try { //mencoba menjalankan perintah Thread.sleep(500); Jika tidak ada pengecualian, maka catch //diabaikan Thread.sleep(500); } catch (InterruptedException ie) {} //jika ada pengecualian 'InterruptedException ie' akan ditangkap catch System.out.println(str2); } }

package contoh5; // mendeklarasikan class yang mengimplementasikan semua method Runnable public class PrintStringsThread implements Runnable { Thread thread; String str1, str2;

//konstruktor dengan parameter str1 dan str2 yang bertipe String PrintStringsThread(String str1, String str2) { this.str1 = str1; this.str2 = str2; thread = new Thread(this);//membuat thread baru bernama thread thread.start(); //memulai untuk mengeksekusi thread } public void run() { //mendeklarasikan method run yang meng-override dari java.lang.Thread dan menjalankan thread TwoStrings.print(str1, str2); //memanggil method print dengan parameter str1 dan str2 dari class TwoString } } package contoh5; public class TestThread { public static void main(String args[]) { new PrintStringsThread("Hello ", "there."); new PrintStringsThread("How are ", "you?"); new PrintStringsThread("Thank you ","very much!"); } }

Analisis Secara garis besar jalannya program pada contoh nomer 5 sama dengan contoh nomer 4, namun menghasilkan hasil yang berbeda karena di contoh nomer 5 pada class TwoString terdapat synchronized static void print(String str1, String str2) yang berarti pada konstruktor ini parameter str1 dan str2 disinkronisasikan atau dikunci sehingga nantinya akan menghasilkan output yang berurutan. Tidak seperti contoh nomer4 yang hasilnya tidak berurutan karena tidak di sinkronisasi.

KESIMPULAN

1. Proses thread merupakan proses ringan / kecil yang sering terjadi dalam sebuah proses di dalam sistem operasi, apabila proses tersebut tidak dikendalikan, maka sistem operasi belum bisa dikatakan maksimal atau optimal. Manajemen proses yang buruk, akan berdampak pada kualitas suatu sistem operasi. 2. Proses proses thread sangat banyak didalam sistem operasi, sehingga perlu dilakukan proses synchronization agar sistem berjalan optimal, mengingat bila proses singel tread tidak dihentikan maka proses akan berjalan sampai proses tersebut selesai dieksekusi. 3. Konsep mutithread membutuhkan synchronization yang lebih kompleks dan rumit. 4. Java telah menyediakan perangkatnya sebagai media mempermudah mempelajari konsep thread seperti synchronized, Thread, Runable, dll.