MULTIHTREADING

Thread yang merupakan cara dari komputer untuk menjalankan dua atau lebih
task dalam waktu bersamaan, sedangkan multithreading adalah cara computer untuk
membagi-bagi pekerjaan yang dikerjakan sebagian-sebagian dengan cepat sehingga
menimbulkan efek seperti menjalankan beberapa task secara bersamaan walaupun
otaknya hanya satu. Multithreading adalah suatu fitur dalam bahasa pemrograman yang
memungkinkan kita membuat dua alur atau lebih dalam sebuah program untuk
melakukan beberapa hal secara “bersamaan” (sebenarnya tidak seratus persen bersamaan
pada mesin dengan satu prosesor, namun sistem memberikan giliran kepada dua proses
atau lebih untuk bekerja secara bergantian dengan waktu yang sangat cepat).

Tujuan kita membuat program dengan kemampuan multithreading adalah:

1. Menghindari bottleneck (dengan hanya sebuah thread, program harus
menghentikan semua operasi ketika sedang menunggu sebuah proses yang
lambat, misalnya mengakses file dalam harddisk, berkomunikasi antarjaringan,
atau menampilkan fitur multimedia);
2. Mengatur perilaku program menjadi lebih baik dan efisien
3. Multiprocessing.

Keuntungan dari sistem yang menerapkan multithreading dapat kita kategorikan

menjadi 4 bagian:
a. Responsif. Aplikasi interaktif menjadi tetap responsif meskipun
sebagian dari program sedang diblok atau melakukan operasi lain yang panjang.
Umpamanya, sebuah thread dari web browser dapat melayani permintaan
pengguna sementara thread yang lain berusaha menampilkan gambar.
b. Berbagi sumber daya. Beberapa thread yang melakukan proses
yang sama akan berbagi sumber daya. Keuntungannya adalah mengizinkan
sebuah aplikasi untuk mempunyai beberapa thread yang berbeda dalam lokasi
memori yang sama.
 c. Ekonomis. Pembuatan sebuah proses memerlukan pengalokasian
memori dan sumber daya. Alternatifnya adalah dengan menggunakan thread,
karena thread membagi memori dan sumber daya yang dimilikinya sehingga lebih
ekonomis untuk membuat thread dan context switching thread.
d. Utilisasi arsitektur multiprosesor. Keuntungan dari
multithreading dapat sangat meningkat pada arsitektur multiprosesor, dimana
setiap thread dapat berjalan secara paralel di atas procesor yang berbeda.

Adapun kerugian dari multithreading adalah :

a. Jika digunakan secara berlebihan, multithreading akan berdampak pada
pemborosan resource dan CPU yang dialokasikan untuk switching threads.
Misalnya jika heavy disk I/O terlibat, akan lebih cepat jika hanya memiliki 1 atau
2 thread yang melaksanakan tugas secara berurutan, daripada menggunakan
multithread yang masing-masing mengeksekusi sebuah task pada waktu yang
sama.
b. Sistem yang memiliki kecepatan prosesor dan memory yang cenderung sama,
sehingga tidak ada efisiensi yang hilang (mengacu kepada latency), tidak akan
memperoleh peningkatan bandwidth yang signifikan jika menggunakan
multithreading.
c. Multithreading menghasilkan program yang lebih kompleks. Menggunakan
multiple thread sendiri tidak akan menciptakan kerumitan, tapi interaksi antar
thread-lah yang mengakibatkan kompleksitas tersebut.
d. Thread yang banyak bisa saling berinterferensi ketika saling berbagi sumber daya
hardware seperti cache.

Sebuah thread memungkinkan untuk memiliki beberapa state:

1. Running
Sebuah thread yang pada saat ini sedang dieksekusi dan didalam control dari
CPU.
2. Ready to run
 Thread yang sudah siap untuk dieksekusi, tetapi masih belum ada kesempatan
untuk melakukannya.
3. Resumed
Setelah sebelumnya di block atau diberhentikan sementara, state ini kemudian
siap untuk dijalankan.
4. Suspended
Sebuah thread yang berhenti sementara, dan kemudian memperbolehkan CPU
untuk menjalankan thread lain bekerja.
5. Blocked
Sebuah thread yang di-block merupakan sebuah thread yang tidak mampu
berjalan, karena ia akan menunggu sebuah resource tersedia atau sebuah event
terjadi.
6. Dead
Setelah keluar dari method run(), thread akan berada dalam status dead dan
menjadi tidak aktif lagi. Status jelas dari sebuah thread tidak dapat diketahui,
tetapi method isAlive() mengembalikan nilai boolean untuk mengetahui apakah
thread tersebut dead atau tidak.
Beberapa terminologi yang akan dibahas:
a. Thread pengguna: Thread yang pengaturannya dilakukan oleh pustaka thread
pada tingkatan pengguna. Karena pustaka yang menyediakan fasilitas untuk
pembuatan dan penjadwalan thread, thread pengguna cepat dibuat dan
dikendalikan.
b. Thread Kernel: . Thread yang didukung langsung oleh kernel. Pembuatan,
penjadwalan dan manajemen thread dilakukan oleh kernel pada kernel space.
Karena dilakukan oleh sistem operasi, proses pembuatannya akan lebih lambat
jika dibandingkan dengan thread pengguna.

Implementasi multithreading yang umum ada tiga, yaitu :

1. many-to-one
Model many-to-one ini memetakan beberapa
tingkatan pengguna thread hanya ke satu buah kernel
thread. Managemen proses thread dilakukan oleh (di
ruang) pengguna, sehingga menjadi efisien, tetapi apabila
sebuah thread melakukan sebuah pemblokingan terhadap
sistem pemanggilan, maka seluruh proses akan berhenti
(blocked). Kelemahan dari model ini adalah multihreads
tidak dapat berjalan atau bekerja secara paralel di dalam
multiprosesor dikarenakan hanya satu thread saja yang
bisa mengakses kernel dalam suatu waktu.

2. one-to-one
Model one-to-one memetakan setiap thread
pengguna ke dalam satu kernel thread. Hal ini
membuat model one-to-one lebih sinkron daripada
model many-to-one dengan mengizinkan thread lain
untuk berjalan ketika suatu thread membuat
pemblokingan terhadap sistem pemanggilan
 Kelemahan model ini adalah dalam pembuatan thread pengguna dibutuhkan
pembuatan korespondensi thread pengguna. Karena dalam proses pembuatan
kernel thread dapat mempengaruhi kinerja dari aplikasi maka kebanyakan dari
implementasi model ini membatasi jumlah thread yang didukung oleh sistem.

3. many-to-many
Beberapa tingkatan thread pengguna dapat
menggunakan jumlah kernel thread yang lebih kecil
atau sama dengan jumlah thread pengguna. Jumlah
dari kernel thread dapat dispesifikasikan untuk
beberapa aplikasi dan beberapa mesin (suatu aplikasi
dapat dialokasikan lebih dari beberapa kernel thread
dalam multiprosesor daripada dalam uniprosesor)
dimana model many-to-one mengizinkan
pengembang untuk membuat thread pengguna
sebanyak mungkin, konkurensi tidak dapat tercapai
karena hanya satu thread yang dapat dijadualkan oleh kernel dalam satu waktu.
Model one-to-one mempunyai konkurensi yang lebih tinggi, tetapi pengembang
harus hati-hati untuk tidak membuat terlalu banyak thread tanpa aplikasi dan
dalam kasus tertentu mungkin jumlah thread yang dapat dibuat dibatasi.

Contoh program thread :

#include <vcl.h>
#pragma hdrstop
#include<iostream.h>
#include<string.h>

class satu
{
public:
void run()
 //{do
{
cout<<"1";
//}while(true);
}
};

class dua
{
public:
void run()
//{do
{
cout<<"2";
//}while(true);
}
};

#pragma argsused
int main(int argc, char* argv[])
{
satu one;
dua two;
{do
{
one.run();
two.run();
}while(true);
}
return 0;
}