Modul B: Contoh Metode yang Disinkronkan Menggunakan Kelas Anonymous dan Contoh Blok yang Disinkronkan

Contoh Metode yang Disinkronkan Menggunakan Kelas Anonymous dan Contoh Blok yang Disinkronkan

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:

Example of synchronized method by using annonymous class

TestSynchronization3.java

Example of Synchronized Block

TestSynchronizedBlock1.java

Synchronized Block Example Using Anonymous Class

TestSynchronizedBlock2.java

Penyelesaian:

1. TestSynchronization3.java

Angka

Code:

//Program of synchronized method by using annonymous class  
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);
            }
        }

    }
}

public class TestSynchronization3 {
    public static void main(String args[]) {
        final Table obj = new Table();// only one object

        Thread t1 = new Thread() {
            public void run() {
                obj.printTable(5);
            }
        };
        Thread t2 = new Thread() {
            public void run() {
                obj.printTable(100);
            }
        };

        t1.start();
        t2.start();
    }
}

Output:

Huruf

Code:

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

public class TestSynchronization3 {
    public static void main(String args[]) {
        final Table obj = new Table();

        Thread t1 = new Thread() {
            public void run() {
                obj.printTable('A', 5);
            }
        };
        Thread t2 = new Thread() {
            public void run() {
                obj.printTable('B', 5);
            }
        };

        t1.start();
        t2.start();
    }
}

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

Kode ini adalah contoh sinkronisasi dalam Java. Dalam contoh ini, kita memiliki kelas `Table` dengan metode `printTable`, yang mencetak karakter tertentu sejumlah kali. Di dalam metode `printTable`, kita menggunakan kata kunci `synchronized` untuk memastikan bahwa hanya satu thread yang dapat mengaksesnya pada satu waktu. Ini memastikan bahwa karakter 'A' dan 'B' dicetak secara bergantian, bukan bersamaan.

Dalam `main` method, dua thread (`t1` dan `t2`) dibuat untuk mengakses objek `Table` yang sama (`obj`). Kedua thread tersebut menjalankan metode `printTable` dengan karakter yang berbeda dan mencetak karakter tersebut beberapa kali.

2. TestSynchronizedBlock1.java

Angka

Code:

class Table  
{      
 void printTable(int n){    
   synchronized(this){//synchronized block    
     for(int i=1;i<=5;i++){    
      System.out.println(n*i);    
      try{    
       Thread.sleep(400);    
      }catch(Exception e){System.out.println(e);}    
     }    
   }    
 }//end of the method    
}    
    
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 TestSynchronizedBlock1{    
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 {
  private int currentIndex = 0;
  private char[] alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray();

  void printTable(int n) {
    synchronized (this) {
      for (int i = 1; i <= 5; i++) {
        System.out.println(alphabet[currentIndex]);
        currentIndex = (currentIndex + 1) % 26;
        try {
          Thread.sleep(400);
        } catch (InterruptedException 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 TestSynchronizedBlock1 {
  public static void main(String args[]) {
    Table obj = new Table();
    MyThread1 t1 = new MyThread1(obj);
    MyThread2 t2 = new MyThread2(obj);
    t1.start();
    t2.start();
  }
}

Output:

a
b
c
d
e
f
g
h
i
j

Kode ini adalah contoh penggunaan sinkronisasi dalam Java untuk memastikan akses yang aman ke sumber daya bersama. Kode ini memiliki tiga kelas utama yaitu Kelas `Table`, Kelas `MyThread1`, Kelas `MyThread2`, dan Kelas `TestSynchronizedBlock1`.

Hasil dari program ini adalah bahwa kedua thread akan mencetak karakter alfabet dari 'a' sampai 'z' sesuai dengan urutan, tetapi mereka akan mencetak karakter tersebut dengan kecepatan yang berbeda, yaitu thread `t1` akan mencetaknya 5 kali, sedangkan thread `t2` akan mencetaknya 100 kali. Keamanan akses ke sumber daya bersama diatur melalui penggunaan `synchronized(this)` dalam metode `printTable`, sehingga hanya satu thread yang bisa menjalankannya pada satu waktu.

3. TestSynchronizedBlock2.java

Angka

Code:

// A Sender class  
class Sender {
  public void SenderMsg(String msg) {
    System.out.println("\nSending a Message: " + msg);
    try {
      Thread.sleep(800);
    } catch (Exception e) {
      System.out.println("Thread interrupted.");
    }
    System.out.println("\n" + msg + "Sent");
  }
}

// A Sender class for sending a message using Threads
class SenderWThreads extends Thread {
  private String msg;
  Sender sd;

  // Receiver method to receive a message object and a message to be sent
  SenderWThreads(String m, Sender obj) {
    msg = m;
    sd = obj;
  }

  public void run() {
    // Checks that only one thread sends a message at a time.
    synchronized (sd) {
      // synchronizing the sender object
      sd.SenderMsg(msg);
    }
  }
}

// Driver Code
public class TestSynchronizedBlock2 {
  public static void main(String args[]) {
    Sender sender = new Sender();
    SenderWThreads sender1 = new SenderWThreads("Hola ", sender);
    SenderWThreads sender2 = new SenderWThreads("Welcome to Javatpoint website ", sender);

    // Start two threads of SenderWThreads type
    sender1.start();
    sender2.start();

    // wait for threads to end
    try {
      sender1.join();
      sender2.join();
    } catch (Exception e) {
      System.out.println("Interrupted");
    }
  }
}

Output:

Sending a Message: Hola 

Hola Sent

Sending a Message: Welcome to Javatpoint website 

Welcome to Javatpoint website Sent

Kode tersebut adalah contoh penggunaan sinkronisasi dalam Java menggunakan blok `synchronized`.

1. Kelas `Sender` memiliki metode `SenderMsg` yang mencetak pesan, menunggu selama 800 ms, dan mencetak pesan lagi.

2. Kelas `SenderWThreads` adalah turunan dari `Thread` yang mengambil pesan dan objek `Sender` sebagai parameter dalam konstruktornya. Dalam metode `run`, itu menggunakan blok `synchronized` pada objek `Sender` untuk memastikan hanya satu thread yang mengirim pesan pada satu waktu.

3. Dalam `main` method, dua thread `sender1` dan `sender2` dibuat untuk mengirim pesan menggunakan objek `Sender`. Thread tersebut dimulai dengan metode `start`, dan kita menggunakan `join` untuk menunggu kedua thread selesai sebelum melanjutkan eksekusi utama.

Hasilnya adalah pesan-pesan yang dicetak secara bergantian oleh kedua thread dengan penundaan 800 ms, menunjukkan penggunaan sinkronisasi untuk mengkoordinasikan akses ke sumber daya bersama.

Search This Blog

SISTEM OPERASI