LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA

NAMA : FAISHAL AFIF

NIM : 205150201111041
MATERI : BAB III
TANGGAL : 25/03/2021
ASISTEN : MUHAMMAD FACHRY NOORCHOOLISH ARIF

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

 Gunakan perintah nano, lalu ketik ulang code yang terdapat pada
langkah a. lalu simpan 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.
 Setelah program baru diatas dijalankan menggunakan command
gcc threadsatu.c –lpthread –o threadsatu
lalu ./threadsatu, maka akan muncul tulisan “Hello!!” dan “How
are you?” yang mengulang terus menerus dengan cepat. Gunakan
Ctrl + C untuk menghentikan program 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

 Gunakan perintah nano, lalu ketik ulang code yang terdapat pada
langkah a. lalu simpan 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.
 Setelah program diatas dijalankan menggunakan command gcc
threaddua.c –lpthread –o threaddua lalu ./threaddua,
maka akan muncul tulisan seperti gambar diatas.

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

Pada terminal satu jalankan program threadsatu dengan

command ./threadsatu dan pada terminal dua jalankan program
threaddua dengan command ./threaddua

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

dengan perintah eksekusi kedua thread tersebut!
 Gunakan command ps –ax untuk menemukan PID. Pada gambar
diatas, PID pada terminal satu atau program threadsatu dapat
ditemukan, sedangkan PID pada terminal dua atau program
threaddua tidak dapat terbaca dengan ps –ax kenapa prosesnya
yang singkat.

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

Pada threadsatu, program tersebut akan terus berjalan, sehingga

sumber daya (waktu) yang diguakan threadsatu pada CPU lebih
banyak. Sedangkan program threaddua berjalan singkat dan
langsung berhenti jika sudah selesai.

Masalah utamanya terdapat pada threaddua yang berjalan dengan

sangat singkat, sehingga sangat sulit untuk menemukan PIDnya.

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 berkas
singlethread.
 Gunakan perintah nano, lalu ketik ulang code yang terdapat pada
langkah a. lalu simpan dengan nama singlethread.c

n. Jalankan, tunjukkan dan berikan penjelasan singkat terkait eksekusi

program tersebut.

Setelah program diatas dijalankan menggunakan command gcc

singlethread.c –lpthread –o singlethread
lalu ./singlethread, maka akan muncul “-a 1024 –i 10000 –
r 50”.

o. Modifikasi kode program tersebut menjadi beberapa thread yang

berbeda dan simpan dengan nama berkas threadtiga.
 Setelah memodifikasi isi dari singlethread, simpan dengan nama
threadtiga.c

p. Deskripsikan hasil eksekusi program threadtiga beserta

penjelasannya.

Setelah program diatas dijalankan menggunakan command gcc

threadtiga.c –lpthread –o threadtiga lalu ./threadtiga,
maka output yang akan muncul
–a 1024 –I 10000 –t 50 –p 2
PROSES MEMBUAT THREAD 1

PROSES MEMBUAT THREAD 2

PROSES JOIN THREAD 1

THREAD (null) DIJALANKAN

THREAD (null) DIJALANKAN

PROSES JOIN THREAD DUA

Values are still consistent

Kode program pada singlethread dimodifikasi dari yang awalnya

hanya memiliki satu thread tunggal, menjadi beberapa thread.
Adapun code yang telah dimodifikasi
pthread_thread[num_thread] yang berarti pthread_t
mereferensikan array pada thread dimana besar size arraynya
sebesar 2 karena pada awal code besar num_thread adalah 2.
 LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA

NAMA : FAISHAL AFIF

NIM : 205150201111041
TUGAS : BAB III
TANGGAL : 25/03/2021
ASISTEN : MUHAMMAD FACHRY NOORCHOOLISH ARIF

1. Dari langkah (a) sampai Langkah (n), jelaskan apa yang anda ketahui
tentang:
(a) thread
(b) single thread
(c) multi thread
Jawab:
(a) Thread merupakan bagian terkecil dari sebuah proses yang
bisa dieksekusi atau dijalankan.
(b) Single thread adalah sebuah lightweight process (proses
sederhana) yang mempunyai thread tunggal yang befungsi
sebagai pengendali atau controller
(c) Multi thread adalah sebuah proses dengan thread yang
banyak dan mengerjakan lebih dari satu tugas dalam satu
waktu.

2. Dari langkah (o) sampai Langkah (p), apa yang anda ketahui dari hasil
eksekusi program ini? Mengapa demikian dan apa yang menjadi dasar
penjelasan anda?
Jawab:
Langkah di atas yaitu langkah memodifikasi code isi dari singlethread
menjadi beberapa thread dan memberi nama threadtiga.c. Code dari
threadtiga megeluarkan output yang berbeda dari singlethread
karena telah dimodifikasi
 LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA

NAMA : FAISHAL AFIF

NIM : 205150201111041
KESIMPULAN : BAB III
TANGGAL : 25/03/2021
ASISTEN : MUHAMMAD FACHRY NOORCHOOLISH ARIF

Tuliskan kesimpulan yang dapat diperoleh dari hasil percobaan ini

berdasarkan hasil pembahasan yang anda buat.

Thread merupakan bagian kecil dari sebuah proses. Suatu proses

dapat memiliki beberapa thread yang nantinya akan mempunyai tugas
masing-masing yang akan dikerjakan. Thread dibedakan menjadi single-
thread dan multi-thread.

Single-thread merupakan thread tunggal (proses sederhana) yang

berfungsi sebagai pengendali. Thread tunggal ini akan menguasai
seluruh sumber daya yang ada pada proses sehingga tidak akan
terjadinya race condition (kondisi dimana thread saling berlomba untuk
menggunakan sumber daya yang dimiliki proses). Contohnya pada
threadsatu.c diatas.

Multithread adalah sebuah proses dengan thread yang banyak dan

mengerjakan lebih dari satu tugas dalam satu waktu yang bersamaan,
dengan kata lain proses ini berbagi sumber daya dengan thread lainnya.
Proses dengan multithread ini akan lebih efisien karena beragam
perintah dapat dikerjakan secara bersamaan