Thread
adalah sebuah alur kontrol dari sebuah proses. Suatu proses yang
multithreaded
mengandung
beberapa perbedaan alur kontrol dengan ruang alamat yang sama. Keuntungan dari
multithreaded meliputi peningkatan respon dari user, pembagian sumber daya
proses, ekonomis, dan kemampuan untuk mengambil keuntungan dari arsitektur
multiprosesor.
User
level thread adalah thread yang tampak oleh programmer dan tidak diketahui oleh
kernel.
User
level thread secara tipikal dikelola oleh sebuah library thread di ruang user.
Kernel level thread didukung dan dikelola oleh kernel sistem operasi. Secara umum,
user level thread lebih cepat dalam pembuatan dan pengelolaan dari pada kernel
thread. Ada tiga perbedaan tipe dari model yang berhubungan dengan user dan
kernel thread atau yang biasa disebut Multithreading Models yaitu :
·
Model many to one: memetakan
beberapa user level thread hanya ke satu buah kernel thread.
ü Konkurensi terbatas
ü Green (Solaris-2), GNU portable thread
·
Model one to one: memetakan setiap
user thread ke dalam satu kernel thread. Berakhir.
ü Proses dicegah tertunda secara total
ü Mahal, satu user thread harus diwakili satu kernel thread
ü Windows NT/XP/2000, Linux, Solaris 9
·
Model many to many: mengizinkan
pengembang untuk membuat user thread sebanyak mungkin, konkurensi tidak dapat
tercapai karena hanya satu thread yang dapat dijadualkan oleh kernel dalam satu
waktu.
ü Banyak user thread dipetakan ke kernel thread
ü Konkurensi optimal
ü Solaris sebelum versi 9, Windows NT/2000 dengan paket
ThreadFiber
TENTANG
THREAD
-Lightweight
process: satuan penggunaan CPU
-Berbagi
resource dengan thread lain dalam sebuah proses
-Proses
(heavyweight process), memilki kontrol tunggal eksekusi
ILUSTRASI : PERBEDAAN PROSES DENGAN THREAD TUNGGAL DAN JAMAK
KEUNTUNGAN
MODEL MULTITHREAD
1)Responsif
! web browser
2)Resource
sharing: aplikasi dengan beberapa thread dapat
menggunakan lokasi memori yang sama
3)Ekonomis:
tanpa alokasi dan dealokasi resource ! resource sharing
4)Skalabilitas:
selain optimasi penggunaan prosesor multicore,
perpindahan antar thread lebih cepat pada single core daripada proses
ILUSTRASI MULTITHREAD SERVER
Ilustrasi arsitektur single core
Ilustrasi arsitektur multi core
JENIS
THREAD
Keduanya
meliputi: pembuatan, penjadwalan dan pengelolaan di levelnya masing-masing
·
User thread
Selalu berasosiasi dengan kernel
thread
Pustaka di level user ! cepat
Salah satu thread yang melakukan
blocking akan mencegah seluruh proses di mana thread tersebut berasal untuk
ditunda (single thread kernel) ! SC: read , sleep
Pthread (POSIX), Win32, Java
·
Kernel thread
Pengelolaan di level kernel lambat dianggap
seperti proses
Salah satu thread yang melakukan
blocking, tidak mencegah seluruh proses tertunda
PUSTAKA
THREAD
Memberikan
API untuk pengembang perangkat lunak mengelola thread
Implementasi:
ü sepenuhnya di user level (-to-one)
ü didukung oleh kernel level (-to-many)
Posix
thread
·
Diimplementasi baik sebagai user
maupun kernel level
·
Standar IEEE 1003.1c: API terkait
pembuatan dan sinkronisasi thread
·
Umum digunakan pada keluarga UNIX
Ilustrasi
posix thread
#include
<stdio.h>
#include
<stdlib.h>
#include
<pthread.h>
int
*a,*b;
void
*vector(void *vargp) {
int
temp,counter,start,finish,ptrNumber,*passVal ;
ptrNumber=*((int
*) vargp); free(vargp);
start=(ptrNumber*25000);
finish=start+25000;
temp=0;
for(counter=start;counter<finish;counter++)
temp+=a[counter]*b[counter];
passVal=malloc(sizeof(int));
*passVal=temp;
pthread_exit(passVal);
}
int
main() {
pthread_t
tid[4];
int
c=0,c1=0,i,*ptr,*passVal,tmp;
a=malloc(100000*sizeof(int));
b=malloc(100000*sizeof(int));
for(i=0;i<1000;i++)
{
a[i]=1+(rand()%1000);
b[i]=1+(rand()%1000);
c+=(a[i]*b[i]);
}
printf("C
total (Sequential) = %d\n",c);
for(i=0;i<4;i++)
{
ptr=malloc(sizeof(int));
*ptr=i;
pthread_create(&tid[i],NULL,vector,ptr);
}
for(i=0;i<4;i++)
{
if((pthread_join(tid[i],
(void**) &passVal))==0) {
tmp=*passVal;
c1+=tmp;
}
else
{
printf("Threads
%d can’t be joined\n",i);
printf("program
terminated\n");
exit(0);
}
}
printf("C
total (Parallel) = %d\n",c1);
printf("\nComparing
sequential and parallel result\n");
if((c-c1)!=0)
printf("pthread
failed...!\n");
else
printf("pthread
success!\n");
return
0;
}
Java
thread
ü
Dikelola JVM
ü
Dibuat dengan mengimplementasi
Runnable
Iluastrasi
java thread
class
MutableInteger {
private
int value;
public
int getValue() {
return
value;
}
public
void setValue(int value) {
this.value=value;
}
}
class
Summation implements Runnable {
private
int upper;
private
MutableInteger sumValue;
public
Summation (int upper, MutableInteger sumValue) {
this.upper=upper;
this.sumValue=sumValue;
}
public
void run() {
int
sum=0;
Thread
thrd=new Thread();
thrd.start();
for(int
i=0; i<upper; i++) {
sum=sum+2;
}
sumValue.setValue(sum);
}
}
public
class Driver {
public
static void main(String[] args) {
if(args.length
> 0) {
if(Integer.parseInt(args[0])<0)
{
System.err.println(args[0]+"
must be>=0.");
}
else
{
MutableInteger
sum=new MutableInteger();
int
upper=Integer.parseInt(args[0]);
Thread
thrd=new Thread(new Summation(upper,sum));
thrd.start();
try
{
thrd.join();
System.out.println("The
sum of "+ upper+ " is " + sum.getValue());
}
catch(InterruptedException
e) {
}
}
}
else
{
System.err.println("Usage:
Driver <Integer Value>");
}
}
}
ISU
DALAM THREAD
SC:
fork&exec
Opsi
saat thread dijalankan:
Menduplikasi
seluruh thread dalam sebuah proses
Menduplikasi
thread yang menjalankan
Pembatalan
thread
Terkait
terminasi thread sebelum seharusnya selesai
Opsi:
Asinkron:
langsung melakukan terminasi
Deffered:
safely cancelation,
Penanganan
signal
Pada
thread:
SIGNAL
dikirimkan ke thread yang menyebabkannya
SIGNAL
dikirimkan ke setiap thread pada proses
SIGNAL
dikirimkan ke thread tertentu pada proses
Menugaskan
sebuah thread untuk menangani semua SIGNAL yang Terjadi
Thread
pools
Multithreaded
server: berpotensi membahayakan sistem jika diijinkan
membuat
thread dalam jumlah sangat banyak (tak hingga)
Dibatasi
jumlah thread yang diijinkan (pools)
Saat
proses dijalankan, sejumlah thread telah disiapkan, menunggu
untuk
memberi layanan pada client
·
Keuntungan:
ü
Lebih cepat daripada konsep
on-demand
ü
Mencegah kegagalan operasi karena
keterbatasan resource
Thread
Specific Data
Memungkinkan
setiap thread memiliki datanya sendiri
for(i=0;i<4;i++)
{
ptr=malloc(sizeof(int));
*ptr=i;
pthread_create(&tid[i],NULL,vector,ptr);
}
CONTOH
SISTEM OPERASI PADA THREAD
WINDOWS
XP
One-to-one
mapping
Berisi:
Identitas
Register,
stack (user & kernel), data khusus 1
Struktur
data utama:
Executive
thread block (ETHREAD)
Kernel
thread block (KTHREAD)
Thread
environment block (TEB)
ILUSTRASI
:
Linux
Thread
Dikenal
sebagai task
Thread
dibuat dengan clone( ) SC
Memungkinkan
berbagi ruang memori antara child-parent, pointer ke lokasi memori
IMPLEMENTASI PAKET
THREAD
1. Thread
level kernel.
Ø Keunggulan
:
ü Memudahkan
koordinasi multithread seperti proses server.
ü Tidak
seboros kumpulan proses tradisional.
Ø Kelemahan
:
ü Operasi
manajemen thread sangat lebih boros.
ü Kernel
harus menyediakan semua feature.
2. Thread
level pemakai.
Ø Keunggulan
:
ü Kinerja
luar biasa bagus disbanding thread level kernel.
ü Tidak
diperlukan modifikasi kernel.
ü Fleksibelitas
tinggi.
Ø Kelemahan
:
ü Tidak
manfaatkan multiprocessor.
ü Untuk
aplikasi dengan keterlibatan kernel yang kecil.
ü Mengharuskan
nonblocking system call.
JENIS
THREAD BERDASARKAN WAKTU PENCIPTANYA
Kategori thread berdasarkan waktu penciptaan :
·
Static threads
Jumlah thread yang akan
dibuat ditentukan saat penulisan dan kompilasi program. Tiap thread langsung
dialokasikan stack tetap.
ü Keunggulannya
: sederhana.
ü Kelemahannya :
tidak fleksibel.
·
Dynamic threads
Penciptaan dan
penghancuran thread “on-the-fly” saat eksekusi. Penciptaan thread biasanya
menspesifikasikan fungsi utama thread (seperti pointer ke procedure) dan ukuran
stack, dapat juga ditambah parameter-parameter lan seperti prioritas
panjadwalan.
ü Keunggulannya
: fleksibel.
ü Kelemahannya : lebih rumit.
Sumber :
https://maungampus.blogspot.com/2013/09/pengertian-thread-dan-macam-macamnya.html
http://tugasqte.blogspot.com/2012/06/thread.html
Tidak ada komentar:
Posting Komentar