Modul A: Memahami Masalah Tanpa Sinkronisasi dan Menggunakan Metode Sinkronisasi Java

Memahami Masalah Tanpa Sinkronisasi dan Menggunakan Metode Sinkronisasi Java

disusun untuk memenuhi

tugas mata kuliah Sistem Operasi

Oleh:

ALFI ZAMRIZA

2208107010080

SEMESTER 3

JURUSAN INFORMATIKA

FAKULTAS METEMATIKA DAN ILMU PENGETAHUAN ALAM

UNIVERSITAS SYIAH KUALA

DARUSSALAM, BANDA ACEH

2023

Soal:

Understanding the problem without Synchronization

Tanpa Sinkronisasi
Menggunakan Metode Sinkronisasi

Penyelesaian:

1. Tanpa Sinkronisasi

Angka

Code:

class Table {
  void printTable(int n) {// method not synchronized
    for (int i = 1; i <= 5; i++) {
      System.out.println(n * i);
      try {
        Thread.sleep(400);
      } catch (Exception e) {
        System.out.println(e);
      }
    }

  }
}

class MyThread1 extends Thread {
  Table t;

  MyThread1(Table t) {
    this.t = t;
  }

  public void run() {
    t.printTable(5);
  }

}

class MyThread2 extends Thread {
  Table t;

  MyThread2(Table t) {
    this.t = t;
  }

  public void run() {
    t.printTable(100);
  }
}

class TestSynchronization1 {
  public static void main(String args[]) {
    Table obj = new Table();// only one object
    MyThread1 t1 = new MyThread1(obj);
    MyThread2 t2 = new MyThread2(obj);
    t1.start();
    t2.start();
  }
}

Output:

Huruf

Code:

class Table{  
void printTable(int n){//method not synchronized  
   for(int i=1;i<=5;i++){  
     System.out.println(n*i);  
     try{  
      Thread.sleep(400);  
     }catch(Exception e){System.out.println(e);}  
   }  
  
 }  
}  
  
class MyThread1 extends Thread{  
Table t;  
MyThread1(Table t){  
this.t=t;  
}  
public void run(){  
t.printTable(5);  
}  
  
}  
class MyThread2 extends Thread{  
Table t;  
MyThread2(Table t){  
this.t=t;  
}  
public void run(){  
t.printTable(100);  
}  
}  
  
class TestSynchronization1{  
public static void main(String args[]){  
Table obj = new Table();//only one object  
MyThread1 t1=new MyThread1(obj);  
MyThread2 t2=new MyThread2(obj);  
t1.start();  
t2.start();  
}  
}  

Kode yang Anda bagikan adalah contoh penggunaan _threading_ dalam Java untuk mencetak huruf-huruf dari 'A' hingga 'Z' dalam dua _thread_ yang berbeda. Mari jelaskan komponen-komponen utama dalam kode ini:

Kelas Table: Ini adalah kelas yang memiliki metode `printTable()`. Metode ini mencetak huruf-huruf dari 'A' hingga 'Z' dalam loop. Setiap huruf dicetak dengan interval _sleep_ sekitar 400 milidetik (0.4 detik) menggunakan `Thread.sleep(400)`.
Kelas MyThread1 dan MyThread2: Ini adalah dua kelas yang meng-_extend_ dari kelas `Thread`. Mereka digunakan untuk membuat dua _thread_ yang berbeda. Setiap _thread_ diinisialisasi dengan objek `Table`, sehingga keduanya akan menggunakan objek yang sama untuk mencetak huruf-huruf
Kelas TestSynchronization1: Ini adalah kelas yang berisi metode `main`. Di dalam metode `main`, objek dari kelas `Table` (obj) dibuat, dan dua _thread_ (`t1` dan `t2`) diinisialisasi dengan objek ini. Kemudian, kedua _thread_ dimulai (`t1.start()` dan `t2.start()`).

Ketika program dijalankan, kedua _thread_ (`t1` dan `t2`) akan mulai mencetak huruf-huruf dari 'A' hingga 'Z' pada objek `Table` yang sama. Karena keduanya menggunakan objek yang sama, Anda mungkin akan melihat huruf-huruf dicetak bergantian oleh kedua _thread_ dalam urutan yang tidak tentu, dengan penundaan 400 milidetik antara setiap cetakan.

Ini adalah contoh sederhana dari penggunaan _multithreading_ dalam Java, yang memungkinkan Anda untuk menjalankan beberapa tugas secara bersamaan. Namun, tanpa sinkronisasi, urutan pencetakan huruf oleh kedua _thread_ mungkin acak dan dapat berubah setiap kali program dijalankan.

Output:

A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
K
K
L
L
M
M
N
N
O
O
P
P
Q
Q
R
R
S
S
T
T
U
U
V
V
W
W
X
X
Y
Y
Z
Z

2. Menggunakan Metode Sinkronisasi

Angka

Code:

//example of java synchronized method  
class Table {
  synchronized void printTable(int n) {// synchronized method
    for (int i = 1; i <= 5; i++) {
      System.out.println(n * i);
      try {
        Thread.sleep(400);
      } catch (Exception e) {
        System.out.println(e);
      }
    }

  }
}

class MyThread1 extends Thread {
  Table t;

  MyThread1(Table t) {
    this.t = t;
  }

  public void run() {
    t.printTable(5);
  }

}

class MyThread2 extends Thread {
  Table t;

  MyThread2(Table t) {
    this.t = t;
  }

  public void run() {
    t.printTable(100);
  }
}

public class TestSynchronization2 {
  public static void main(String args[]) {
    Table obj = new Table();// only one object
    MyThread1 t1 = new MyThread1(obj);
    MyThread2 t2 = new MyThread2(obj);
    t1.start();
    t2.start();
  }
}

Output:

Huruf

Code:

class Table {
  synchronized void printTable(char startChar, char endChar) {
    for (char c = startChar; c <= endChar; c++) {
      System.out.println(c);
      try {
        Thread.sleep(400);
      } catch (Exception e) {
        System.out.println(e);
      }
    }
  }
}

class MyThread1 extends Thread {
  Table t;

  MyThread1(Table t) {
    this.t = t;
  }

  public void run() {
    t.printTable('A', 'M'); // 'A' to 'M' for the first thread
  }
}

class MyThread2 extends Thread {
  Table t;

  MyThread2(Table t) {
    this.t = t;
  }

  public void run() {
    t.printTable('N', 'Z'); // 'N' to 'Z' for the second thread
  }
}

public class TestSynchronization2 {
  public static void main(String args[]) {
    Table obj = new Table();
    MyThread1 t1 = new MyThread1(obj);
    MyThread2 t2 = new MyThread2(obj);
    t1.start();
    t2.start();
  }
}

Kode di atas adalah contoh penggunaan metode yang disinkronkan dalam Java dengan dua _thread_ yang mencetak huruf-huruf dari 'A' hingga 'M' (dalam _thread_ pertama) dan 'N' hingga 'Z' (dalam _thread_ kedua).

Berikut adalah penjelasan tentang setiap komponen dalam kode tersebut:

Kelas Table: Ini adalah kelas yang memiliki metode `printTable(char startChar, char endChar)`. Metode ini adalah metode yang disinkronkan (dengan kata kunci `synchronized`). Ia mencetak huruf-huruf dalam jangkauan yang ditentukan oleh parameter `startChar` dan `endChar`. Setiap huruf dicetak dengan jeda 400 milidetik menggunakan `Thread.sleep(400)`.
Kelas MyThread1 dan MyThread2: Ini adalah dua kelas yang meng-_extend_ dari kelas `Thread`. Mereka digunakan untuk membuat dua _thread_ yang berbeda. Setiap _thread_ diinisialisasi dengan objek `Table`, sehingga keduanya akan menggunakan objek yang sama untuk mencetak huruf-huruf.
Kelas TestSynchronization2: Ini adalah kelas yang berisi metode `main`. Di dalam metode `main`, objek dari kelas `Table` (obj) dibuat, dan dua _thread_ (`t1` dan `t2`) diinisialisasi dengan objek ini. Kemudian, kedua _thread_ dimulai (`t1.start()` dan `t2.start()`).

Ketika program dijalankan, _thread_ pertama (`t1`) akan mencetak huruf-huruf dari 'A' hingga 'M' secara berurutan dengan penundaan 400 milidetik antara setiap huruf. Pada saat yang sama, _thread_ kedua (`t2`) akan mencetak huruf-huruf dari 'N' hingga 'Z' dalam urutan yang sama dengan penundaan yang sama.

Karena metode `printTable` di dalam kelas `Table` adalah metode yang disinkronkan, hanya satu _thread_ yang dapat memasuki metode tersebut pada satu waktu. Oleh karena itu, kedua _thread_ akan mencetak huruf-huruf mereka secara bersamaan, dan hasil cetakan akan diatur sesuai dengan jeda yang diberikan.

Output:

A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

Kesimpulan

Dari dua kode yang telah Anda berikan, yang pertama tanpa sinkronisasi dan yang kedua menggunakan metode sinkronisasi, kita dapat menarik beberapa kesimpulan tentang perbedaan antara keduanya:

Kode Tanpa Sinkronisasi:

Kode pertama tidak menggunakan sinkronisasi, sehingga kedua _thread_ dapat menjalankan metode `printTable` secara bersamaan.
Hal ini mengakibatkan output yang tidak teratur dan campuran antara cetakan dari _thread_ pertama dan kedua.
Tidak ada jaminan urutan eksekusi, dan _race condition_ dapat terjadi, menghasilkan hasil yang tidak konsisten.

Kode Menggunakan Metode Sinkronisasi:

Kode kedua menggunakan kata kunci `synchronized` pada metode `printTable`, sehingga hanya satu _thread_ dapat menjalankan metode tersebut pada satu waktu.
Hasil cetakan menjadi lebih terstruktur dan teratur, dengan _thread_ pertama mencetak 'A' hingga 'M' dan _thread_ kedua mencetak 'N' hingga 'Z'.
_Thread_ akan menunggu satu sama lain dan urutan eksekusi akan lebih terorganisir.

Kesimpulannya, penggunaan metode yang disinkronkan (dengan kata kunci `synchronized`) dalam kasus ini sangat penting untuk menghindari _race condition_ dan memastikan bahwa _thread_ berinteraksi dengan objek bersamaan secara aman. Dengan demikian, kode yang menggunakan sinkronisasi memberikan hasil yang lebih dapat diandalkan dan terorganisir daripada kode tanpa sinkronisasi.

Search This Blog

SISTEM OPERASI