LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA

NAMA : YOLANDA SAPUTRI

NIM : 195150201111064
MATERI : BAB III
TANGGAL : 04/11/2020
ASISTEN : FRANKLID GUNAWAN

BAB 3
THREAD
3.1. Tujuan Praktikum
Memperkenalkan thread dalam bentuk single thread dan multithread
secara sederhana

3.2. Capaian Praktikum

1. Mahasiswa mampu mengenali karakteristik thread
2. Mahasiswa mampu mengenali karakteristik single thread dan
multithread

3.3. Dasar Teori

Thread merupakan bagian terkecil dari sebuah proses yang bisa
dieksekusi atau dijalankan. Satu proses bisa mememiliki beberapa thread
yang dapat dieksekusi secara asinkron. Dengan cara asinkron ini, setiap
thread dapat menangani pekerjaan atau layanan tertentu secara
independent. Layanan independent ini akan setara dengan hasil eksekusi
seluruh proses dengan lengkap.Pada system operasi modern, thread telah
menjadi bagian yang sangat penting. Jika pada sebuah proses yang
berfungsi menerima beberapa masukan secara real time, akan
menghasilkan luaran tertentu sesuai dengan masing masing masukan yang
ada. Tanpa thread, maka proses ini dieksekusi secara secara sinkron.
Dalam proses sinkron eksekusi dilakukan secara berurutan. Kelemahan
dari proses sinkron adalah harus menunggu sampai semua urutan instruksi
selesai dieksekusi. Jika instruksi yang menjalankan satu masukan
berlangsung lama, maka instruksi yang menjalankan masukan yang lain
harus menunggu. Untuk mengatasi masalah ini, thread menjadi pilihan
karena dapat menjalankan instruksi secara asinkron.

Perbedaan utama antara proses dan thread adalah sebagai berikut:

Proses Thread
Tidak berbagi dengan Berbagi dengan
Pengalamatan
proses lain thread lain yang
 dieksekusi dengan
proses yang memiliki
proses ID yang sama
Proses dieksekusi
Sinkronisasi thread
secara independent
Eksekusi dan diatur oleh proses
dan berbeda antara
Sinkronisasi yang memiliki thread
satu proses dengan
tersebut
proses yang lain
Context Switch Lebih lama Lebih cepat
Interaksi bisa lebih
Interaksi antara dua mudah karena thread
proses hanya dapat berbagi sumber daya
Interaksi dilakukan dengan dengan thread yang
komunikasi antar lain seperti memori,
proses segmen text dan lain
lain

Meski thread memiliki kemudahan dan kecepatan yang lebih baik,

terdapat beberapa permasalahan yang mungkin muncul. Diantaranya
adalah kemungkinan terjadinya overwrite data dan isi memori secara
keseluruhan jika sebuah thread mengeksekusi aplikasi lain atau aplikasi
baru yang berbeda.

Masalah lain yang mungkin timbul adalah masalah konsistensi data.

Kecuali stack, thread berbagi hampir semua komponen dengan thread yang
lain. Eksekusi thread dapat dihentikan setiap saat (preemptive) pada tahap
apapun oleh thread yang lain. Sehingga memungkinkan variable atau
struktur data global yang ada menjadi tidak konsisten. Inkonsistensi data
dapat menyebabkan masalah saat thread yang berbeda mengeksekusi
fungsi yang sama dan menggunakan variable atau struktur data yang sama.
 Gambar 3.1. Inkonsistensi Data Karena Penggunaan Thread

3.4. Langkah Praktikum

Praktikum ini dilakukan dengan terlebih dahulu terhubung dengan
layanan aws educate dengan cara mengaktifkan instance dari halaman
instance summary. Pilih action dan Start untuk mengaktifkan instance.
Lakukan koneksi SSH dengan cara yang sama seperti pada Bab 1.

a. Tuliskan kode berikut ini dengan text editor

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

void * thread1() {
while(1) {
printf("Hello!!\n");
}
}

void * thread2() {
while(1) {
printf("How are you?\n");
}
}

int main() {
int status;
pthread_t tid1,tid2;
pthread_create(&tid1,NULL,thread1,NULL);
pthread_create(&tid2,NULL,thread2,NULL);
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
return 0;
 }

b. Simpan berkas tersebut dengan nama threadsatu.c

c. Kompilasi program dengan perintah

[admin@host]$ gcc threadsatu.c –lpthread –o threadsatu

d. Jalankan program baru tersebut diatas. Tunjukkan tampilan yang

ada pada terminal serta berikan penjelasan singkat dari tampilan
tersebut.

e. Tuliskan kode berikut ini

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

pthread_t tid[2];

void* doSomeThing(void *arg) {

unsigned long i = 0;
pthread_t id = pthread_self();

if(pthread_equal(id,tid[0])) {
printf("\n First thread processing\n");
} else {
printf("\n Second thread processing\n");
}

for(i=0; i<(0xFFFFFFFF);i++);
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));
else
printf("\n Thread created
successfully\n");
i++;
}
sleep(5);
return 0;
 }

f. Simpan berkas kedua ini dengan nama threaddua.c

g. Kompilasi kode program threaddua.c melalui terminal dengan

menuliskan perintah
[admin@host]$ gcc threaddua.c –lpthread –o threaddua

h. Jalankan program baru tersebut diatas. Tunjukkan tampilan yang

ada pada terminal serta berikan penjelasan singkat dari tampilan
tersebut.

i. Buka aplikasi terminal yang lain, dan jalankan kedua thread tersebut.

j. Temukan identitas proses (dan mungkin juga thread) yang terkait

dengan perintah eksekusi kedua thread tersebut!

k. Apakah yang bisa dijelaskan dari kedua contoh thread diatas? Apa
yang menjadi masalah utama dalam hal ini?

l. Berikut ini adalah sebuah kode program yang dijalankan secara

sekuensial. Dibentuk menjadi satu proses dengan single thread.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

static int num_accts = 1024; // number of bank accounts

static int num_trans = 10000; // number of transactions
static int think_time = 50; // amount of "thinking
time"

struct acct_t { int bal; };

/*
* Pointer to accounts
*/
struct acct_t *accts;

/*
* Method to perform a number of transactions.
* Parameter "dummy" is not used.
*/
void *transact(void *dummy) {
int i;
for (i = 0; i < num_trans; i++) {
// pick two random accounts
int acct_id_from = rand() % num_accts;
int acct_id_to = rand() % num_accts;

// pick a random amount

 int amt = rand() % 100;

// try to transfer the money

if (accts[acct_id_from].bal > amt) {
accts[acct_id_from].bal -= amt;
accts[acct_id_to].bal += amt;

// "thinking time"... don't modify

this code!!
amt *= think_time; while (amt--) ;
}
}
}

int main(int argc, char **argv) {

// make sure the number of arguments is odd
(including the program name)
if (!(argc == 1 || argc == 3 || argc == 5 || argc
== 7)) {
fprintf(stderr, "usage: %s [-a <accts>] [-
i <transactions>] [-t <think-time>]\n",
argv[0]);
exit(-1);
}

// look at each runtime argument and see which

value it's attempting to set
int i;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-a")) {
num_accts = atoi(argv[i+1]);
i++;
} else if (!strcmp(argv[i], "-i")) {
num_trans = atoi(argv[i+1]);
i++;
} else if (!strcmp(argv[i], "-t")) {
think_time = atoi(argv[i+1]);
i++;
} else {
fprintf(stderr, "usage: %s [-a
<accts>] [-i <transactions>] [-t <thinktime>]\n",
argv[0]);
exit(-1);
}
}

// display the parameters that will be used for

this test run
fprintf(stderr, "%s: -a %d -i %d -t %d\n",
argv[0], num_accts, num_trans, think_time);

// initialize the random number generator

srand(1);
 // create the bank accounts
accts = (struct acct_t *)malloc(num_accts *
sizeof(struct acct_t));

// initialize the bank accounts' values and keep

track of the total sum in all accounts
int original_sum = 0;
for (i = 0; i < num_accts; i++) {
accts[i].bal = rand() % 1000;
original_sum += accts[i].bal;
}

// call the transact function to do the transfers

transact(NULL);

// find the total sum of all accounts after the

transfers are done
int sum = 0;
for (i = 0; i < num_accts; i++) {
sum += accts[i].bal;
}

// if the sum is not equal to the original sum,

then we had a race condition!!
if (sum != original_sum) {
fprintf(stderr, "ERROR! original_sum = %d,
sum = %d\n", original_sum, sum);
} else {
fprintf(stderr, "Values are still
consistent\n");
}
return 0;
}

m. Kompilasi kode program tersebut dan simpan dengan nama berkasi

singlethread.

n. Jalankan, tunjukkan dan berikan penjelasan singkat terkait eksekusi

program teresbut.

o. Modifikasi kode program tersebut menjadi beberapa thread yang

berbeda dan simpan dengan nama berkas threadtiga.

p. Deskripsikan hasil eksekusi program threadtiga beserta

penjelasannya.
 LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA

NAMA : YOLANDA SAPUTRI

NIM : 195150201111064
TUGAS : BAB III
TANGGAL : 04/11/2020
ASISTEN : FRANKLID GUNAWAN

1. Dari langkah (a) sampai Langkah (n), jelaskan apa yang anda ketahui
tentang:
(a) thread
(b) single thread
(c) multi thread
Jawab:
 Gambar 1 Screenshot hasil dari langkah a (menulis kode pada nano)

Gambar 2 Screenshot hasil langkah b (menyimpan kode dengan nama threadsatu.c)

Gambar 3 Screenshot hasil langkah c (kompilasi program)

 Gambar 4 Screenshot hasil langkah d (menjalankan dan menampilkan hasil)

Menuliskan kode program threadsatu.c pada nano dengan

membuka text editor nano seperti pada Gambar 1 dan
menyimpannya dengan nama threadsatu.c seperti pada Gambar
2. Kemudian keluar dari nano untuk mengkompilasi program tersebut
dengan perintah gcc threadsatu.c –lpthread –o threadsatu
seperti pada Gambar 3. Setelah menjalankan program tersebut
dengan perintah ./threadsatu maka akan muncul tampilan seperti
pada Gambar 4. Tampilan tersebut membuktikan saat program
threadsatu.c dijalankan, maka program tersebut menjalankan
thread1 sesuai kode program dengan output “Hello!!” dan untuk
thread2 outputnya “How are you?”. Hasil dari thread1 dan
thread2 akan berjalan secara terus menerus (looping) dan sesuai
dengan outputnya secara bergantian dari “Hello!!” kemudian “How
are you?” yang berarti bahwa thread dikerjakan secara bergantian.
 Gambar 5 Screenshot hasil langkah e (menulis kode pada nano)

Gambar 6 Screenshot hasil langkah f (menyimpan kode dengan nama threaddua.c)

 Gambar 7 Screenshot hasil langkah g (kompilasi program)

Gambar 8 Screenshot hasil langkah h (menjalankan dan menampilkan hasil)

Menuliskan kode program threaddua.c pada nano dengan

membuka text editor nano seperti pada Gambar 5 dan
menyimpannya dengan nama threadsatu.c seperti pada Gambar
6. Kemudian keluar dari nano untuk mengkompilasi program tersebut
dengan perintah gcc threaddua.c –lpthread –o threaddua
seperti pada Gambar 7. Setelah menjalankan program tersebut
dengan perintah ./threaddua maka akan muncul tampilan seperti
pada Gambar 8. Tampilan tersebut memunculkan keluaran “Thread
created successfully” yang berarti bahwa thread1 dan
thread2 telah berhasil dibuat. Tampilan “Second Thread
processing” dan “First Thread processing” berarti bahwa
eksekusi thread sedang berjalan namun eksekusinya berjalan
dengan tidak berurutan.

Gambar 9 Screenshot hasil langkah i (menjalankan kedua thread dengan 2 terminal)

Gambar 10 Screenshot hasil menjalankan langkah j

Gambar 11 Screenshot hasil menjalankan langkah j

Pada langkah i yaitu menjalankan kedua thread dengan terminal yang
berbeda secara bersama-sama seperti pada Gambar 9. Selanjutnya
membuka satu terminal lagi untuk menemukan identitas proses yang
terkait dengan perintah eksekusi kedua thread tersebut dan ID
Process yang ditunjukkan dengan perintah “ps -ax” adalah 18091
untuk “threadsatu” serta 18094 untuk “threaddua” seperti pada
Gambar 10. Lalu melanjutkan dengan perintah “pstree”
menggunakan terminal yang sama dengan “ps -ax” sebelumnya
dengan hasil keluaran seperti pada Gambar 11. Gambar 11
menampilkan 2* yang menandakan jika proses yang sedang berjalan
adalah dua thread yaitu threadsatu dan threaddua.

Untuk langkah k menjelaskan bahwa dari kedua thread yang sedang

berjalan tersebut memiliki ID Process yang berbeda. Serta urutan
eksekusi setiap thread juga tidak tetap, bergantung dengan algoritma
schedulling.

Gambar 12 Screenshot hasil langkah l (menulis kode pada nano)

 Gambar 13 Screenshot hasil langkah m (menyimpan kode dengan nama singlethread.c)

Gambar 14 Screenshot hasil langkah n (mengkompilasi dan menjalankan)

Menuliskan kode program singlethread.c pada nano dengan

membuka text editor nano seperti pada Gambar 12 dan
menyimpannya dengan nama threadsatu.c seperti pada Gambar
13. Kemudian keluar dari nano untuk mengkompilasi program
tersebut dengan perintah gcc singlethread.c –lpthread –o
singlethread seperti pada Gambar 14. Setelah menjalankan
program tersebut dengan perintah ./singlethread maka akan
muncul tampilan seperti pada Gambar 14. Tampilan tersebut
memunculkan keluaran berupa informasi tentang number account,
number transaction dan running time dari program tersebut yaitu “-a
1024 -i 10000 -t 50” serta “Valued are still consistent”.
 Dari langkah a hingga n saya mengetahui tentang :

a) Thread adalah suatu unit terkecil dalam suatu process yang

dijadwalkan oleh sistem operasi. Sebuah proses dapat terdiri
dari satu thread ataupun lebih dan thread juga bisa
dieksekusi seperti process. Suatu thread berbagi code
section dan resource dengan thread lain yang memiliki
process yang sama.
b) Single Thread adalah sebuah lightweight process yang terdiri
dari thread tunggal yang berfungsi sebagai pengendali atau
controller.
c) Multi Thread adalah sebuah process yang terdiri dari banyak
thread dan dapat mengerjakan banyak tugas dalam satu
waktu.

2. Dari langkat (o) sampai Langkah (p), apa yang anda ketahui dari hasil
eksekusi program ini? Mengapa demikian dan apa yang menjadi dasar
penjelasan anda?
Jawab:

Gambar 15 Screenshot hasil langkah o (memodifikasi kode dan menyimpan dengan nama
threadtiga.c
 Gambar 16 Screenshot hasil eksekusi

Memodifikasi kode program singlethread.c menjadi beberapa

thread yang berbeda pada nano dengan membuka text editor nano
dan menyimpannya dengan nama threadtiga.c seperti pada
Gambar 15. Kemudian keluar dari nano untuk mengkompilasi
program tersebut dengan perintah gcc threadtiga.c –lpthread
–o threadtiga lalu menjalankan program tersebut dengan
perintah ./threadtiga maka akan muncul tampilan seperti pada
Gambar 16. Tampilan tersebut memunculkan keluaran berupa
informasi tentang number account, number transaction, running time
dan jumlah thread dari program tersebut yaitu “-a 1024 -i 10000
-t 50 -p 2” serta hasil akhirnya “Valued are still consistent”
karena tidak terjadi kondisi race ketika proses sedang berjalan. Saat
single thread dimodifikasi menjadi multi thread sehingga program
akan terdapat lebih dari satu thread. Dengan modifikasi tersebut akan
memberikan efisiensi waktu terhadap threadtiga yaitu running time
execution yang sama dari program single thread namun dijalankan
dalam beberapa thread yang berbeda serta sejenis dapat melakukan
tugas dalam satu waktu.
 LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA

NAMA : YOLANDA SAPUTRI

NIM : 195150201111064
KESIMPULAN : BAB III
TANGGAL : 04/11/2020
ASISTEN : FRANKLID GUNAWAN

Tuliskan kesimpulan yang dapat diperoleh dari hasil percobaan ini

berdasarkan hasil pembahasan yang anda buat.

Thread adalah suatu unit terkecil dalam suatu process yang

dijadwalkan oleh sistem operasi. Sebuah proses dapat terdiri dari satu
thread ataupun lebih dan thread juga bisa dieksekusi seperti process.
Suatu thread berbagi code section dan resource dengan thread lain yang
memiliki process yang sama. Dengan thread menjadikan suatu proses
dapat mengeksekusi instruksi dalam program secara asinkron tanpa
menunggu instruksi sebelumnya selesai dieksekusi. Sehingga membuat
komputasi lebih efisien jika menggunakan thread.

Single Thread adalah sebuah lightweight process yang terdiri dari

thread tunggal yang berfungsi sebagai pengendali atau controller.
Sedangkan Multi Thread adalah sebuah process yang terdiri dari banyak
thread dan dapat mengerjakan banyak tugas dalam satu waktu. Namun
semakin banyak thread yang dibuat dan dijalankan, maka resource yang
diperlukan untuk eksekusi program agar lebih cepat. Masalah yang terjadi
dalam penggunaan thread ini jika thread memasuki race condition yaitu
overwrite data dan memori maupun masalah kekonsistenan data.