Nama : Raden Mas Xyla Ramadhan

NPM : 0617101017
Kelas : A

TUGAS KUIS SISTEM OPERASI

1. Carilah contoh program tentang Akun Bank yang dapat menunjukkan perlunya Mutex di
dalamnya dan jelaskan
2. Apakah persamaan dan perbedaan semaphore dan mutex ? Berikan juga contoh program
yang mendukungnya dan jelaskan.
3. Kondisi apa saja yang menyebabkan deadlock? Carilah contoh program yang menunjukkan
deadlock (Bukan program/algoritma untuk mencegah deadlock)

Jawaban
1. Contoh Program Akun Bank

Source code Account Bank

package main

import (
"fmt"
"sync"
)

var (
mutex sync.Mutex
balance int
)

func init() {
balance = 1000
}

func deposit(value int, done chan bool) {

mutex.Lock()
fmt.Printf("Depositing %d to account with balance: %d\n", value, balance)
balance += value
mutex.Unlock()
done <- true
}

func withdraw(value int, done chan bool) {

mutex.Lock()
fmt.Printf("Withdrawing %d from account with balance: %d\n", value, balance)
balance -= value
mutex.Unlock()
done <- true
}

func main() {
fmt.Println("Go Mutex Example")

done := make(chan bool)

go withdraw(700, done)
 go deposit(500, done)
<-done
<-done

fmt.Printf("New Balance %d\n", balance)

}

1.1 Perlunya Mutex di Program dan jelaskan

Perlunya Mutex adalah untuk memperoleh lock pada mutex yang melindungi setiap akun

Jadi, mari uraikan program di atas. Dalam fungsi deposit() dan withdraw () kami, kami telah
menentukan langkah pertama yang harus diambil untuk mendapatkan mutex menggunakan metode
mutex.Lock ().

Setiap fungsi akan diblokir sampai berhasil memperoleh Key. Setelah berhasil, program akan
melanjutkan untuk memasuki bagian kritis di mana ia membaca dan kemudian memperbarui saldo
akun. Setelah masing-masing fungsi melakukan tugasnya, program kemudian mulai melepaskan key
dengan memanggil metode mutex.Unlock ().
Ketika Anda menjalankan kode ini, Anda akan melihat output berikut:
Depositing 500 to account with balance: 300
Withdrawing 700 from account with balance: 1000
New Balance 800
Kesimpulan
Jadi, dalam program ini, kami telah melihat Race Condition dan bagaimana mereka dapat
menghancurkan kekacauan pada sistem yang bersamaan. Kami kemudian melihat bagaimana kami
dapat menggunakan mutex untuk melindungi kami dari race condition dan memastikan bahwa sistem
kami bekerja dengan sesuai

2. Persamaan dan Perbedaan Mutex dan Semaphore

Mutex adalah singkatan dari mutual exclusion, dimana jika ada 3 proses yang akan berjalan secara
bersamaan, mutex menyediakan fitur lock and release, dimana lock tersebut bekerja sebagai kunci
yang dapat membuka suatu jalur agar sebuah proses dapat berjalan dengan semestinya. Anggap
mutex sebagai cara kerja jika orang yang sedang berada di rumah yang hanya memiliki satu pintu
dan satu kunci. Analogikan bahwa orang yang berada dalam rumah tersebut adalah sebuah proses,
rumah itu sendiri adalah sebuah Sistem Operasi, dan kunci tersebut adalah fitur mutex yang dapat
menjalankan sistem lock and release. Jika satu orang ingin keluar rumah tersebut, maka harus
mengambil kunci tersebut, dan sisa orang dirumah tersebut tidak dapat mengambil kuncinya karena
sedang dipakai oleh satu orang tersebut. Maka, proses dapat berjalan dengan sebagaimana
mestinya.

Semaphore juga merupakan suatu proses penggunaan fitur lock and release. Letak perbedaannya
hanyalah dimana semaphore membatasi jumlah proses serta jumlah semaphore yang akan
digunakan. Jika semaphore yang disediakan hanya berjumlah 2, makan proses yang harus berjalan
hanya boleh 2 proses. Jika semaphore yang disediakan hanya berjumlah 3, maka proses yang harus
berjalan hanya boleh 3 proses. Analogikan sebagai restoran yang hanya menyediakan 500 piring nasi
goreng pada suatu acara. Berarti, orang yang datang ke acara tersebut hanya dibatasi sebanyak 500
pengunjung, tidak boleh lebih. Jika lebih, maka mereka tidak akan kebagian piring nasi goreng. Sama
halnya dengan semaphore, jika jumlah proses melebihi jumlah semaphore, maka akan terjadi
sebuah error.

Persamaan Mutex dan Semaphore

 Proses penggunaan fitur lock and release

Perbedaan Mutex dan Semaphore

 Semaphore membatasi jumlah proses serta jumlah semaphore yang akan digunakan
 Mutex bekerja sebagai kunci yang dapat membuka suatu jalur agar sebuah proses dapat
berjalan dengan semestinya
 Mutex menyediakan inversi prioritas yang aman.

 Contoh mutex adalah jika ada 3 proses dan 1 proses menjalan fitur mutex
(lock and release), maka proses lainnya tidak bisa menjalankan fitur mutex
karena sudah dipakai oleh proses yang pertama.

Contoh Program Mutex

#include<stdio.h>

#include<string.h>

#include<pthread.h>

#include<stdlib.h>

#include<unistd.h>
pthread_t tid[2];

int counter;

void* doSomeThing(void *arg)

unsigned long i = 0;

counter += 1;

printf("\n Job %d started\n", counter);

for(i=0; i<(0xFFFFFFFF);i++);

printf("\n Job %d finished\n", counter);

return NULL;

int main(void)

int i = 0;

int err;

while(i < 2)
 {

err = pthread_create(&(tid[i]), NULL, &doSomeThing, NULL);

if (err != 0)

printf("\ncan't create thread :[%s]", strerror(err));

i++;

pthread_join(tid[0], NULL);

pthread_join(tid[1], NULL);

return 0;

Kode di atas adalah kode sederhana di mana dua thread (pekerjaan) dibuat dan pada fungsi awal
utas ini, sebuah penghitung dipertahankan melalui mana pengguna mendapatkan log tentang nomor
pekerjaan yang dimulai dan ketika selesai. Kode dan alurnya terlihat baik tetapi ketika kita melihat
hasilnya:

$ ./tgsthreads

Pekerjaan 1 dimulai

Pekerjaan 2 dimulai

Pekerjaan 2 selesai

Pekerjaan 2 selesai

Jika Anda fokus pada dua log terakhir, Anda akan melihat bahwa log 'Pekerjaan 2 selesai' diulang dua
kali sementara tidak ada log untuk 'Pekerjaan 1 selesai' terlihat.

Contoh Program Semaphore

#include <stdio.h>

#include <pthread.h>

#include <semaphore.h>

#include <unistd.h>
sem_t mutex;

void* thread(void* arg){

//wait

sem_wait(&mutex);

printf("\nEntered..\n");

//Critical Section

sleep(4);

//Signal

printf("\nJust Exiting..\n");

sem_post(&mutex);

int main(){

sem_init(&mutex, 0, 1);

pthread_t t1, t2;

pthread_create(&t1, NULL, thread, NULL);

sleep(2);

pthread_create(&t2, NULL, thread, NULL);

pthread_join(t1, NULL);

pthread_join(t2, NULL);

sem_destroy(&mutex);

return 0;

Dari Program di atas Semaphore membatasi jumlah proses dan jumlah semaphore yang akan
digunakan.

Outputnya
 3. Kondisi yang Menyebabkan Deadlock

Deadlock adalah suatu kondisi dimana dua proses atau lebih saling menunggu proses
yang lain untuk melepaskan resource yang sedang dipakai. Karena beberapa proses itu
saling menunggu, maka tidak terjadi kemajuan dalam kerja proses-proses
tersebut. Deadlock adalah masalah yang biasa terjadi ketika banyak proses yang
membagi sebuah resource yang hanya boleh dirubah oleh satu proses saja dalam satu
waktu.

Di kehidupan nyata, deadlock dapat digambarkan dalam gambar berikut.Pada gambar

diatas, deadlock dianalogikan sebagai dua antrian mobil yang akan menyeberangi
jembatan.

Contoh Deadlock

Dalam kasus diatas, antrian di sebelah kiri menunggu antrian kanan untuk
mengosongkan jembatan (resource), begitu juga dengan antrian kanan. Akhirnya tidak
terjadi kemajuan dalam kerja dua antrian tersebut.Misal ada proses A
mempunyai resource X, proses B mempunyai resource Y. Kemudian kedua proses ini
dijalankan bersama, proses A memerlukan resourceY dan proses B
memerlukan resource X, tetapi kedua proses tidak akan memberikan resource yang
dimiliki sebelum proses dirinya sendiri selesai dilakukan. Sehingga akan terjadi
tunggu-menunggu.

Contoh Program

#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
pthread_mutex_t resource1,resource2;
int test=0;
void *proc1()
{
printf("\n Ini adalah proc1 menggunakan rs1");
pthread_mutex_lock(&resource1);
usleep(200);
printf("\n proc1 mencoba ke rs2...");
pthread_mutex_lock(&resource2);
test++;
printf("\n proc1 mendapatkan rs2!!");
pthread_mutex_unlock(&resource2);
pthread_mutex_unlock(&resource1);
return 0;
}

void *proc2()
{
printf("\n Ini adalah proc2 menggunakan rs2");
pthread_mutex_lock(&resource2);
usleep(200);
printf("\n proc2 mencoba ke rs1...");
pthread_mutex_lock(&resource1);
test--;
printf("\n proc2 mendapatkan rs1!!");
pthread_mutex_unlock(&resource1);
pthread_mutex_unlock(&resource2);
return 0;
}

int main(){
pthread_t t1,t2;
pthread_mutex_init(&resource1, NULL);
pthread_mutex_init(&resource2, NULL);

pthread_create(&t1,NULL, proc1 , NULL);

pthread_create(&t2,NULL, proc2 , NULL);

pthread_join(t1,NULL);
pthread_join(t2,NULL);

pthread_mutex_destroy(&resource1);
pthread_mutex_destroy(&resource2);
}

Program diatas akan menyebakan deadlock yang mengakitbatkan sebuah program

mengalami Hang