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 :
1)Model many to one: memetakan beberapa user level
thread hanya ke satu buah kernel thread.
2)Model one to one: memetakan setiap user thread ke
dalam satu kernel thread. Berakhir.
3)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.
TENTANG THREAD
-Lightweight process: satuan penggunaan CPU
-Berbagi resource dengan thread lain dalam sebuah
proses
-Proses (heavyweight process), memilki kontrol tunggal
eksekusi
JENIS THREAD
1)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
2)Kernel thread
Pengelolaan di level kernel
lambat
dianggap seperti proses
Salah satu thread yang melakukan blocking, tidak
mencegah seluruh
proses tertunda
MODEL THREAD
1)MANY
TO ONE
-Konkurensi terbatas
-Green (Solaris-2), GNU
portable thread
2)ONE
TO ONE
-Proses dicegah tertunda secara total
-Mahal, satu user thread harus diwakili satu kernel
thread
-Windows NT/XP/2000, Linux, Solaris 9
3)MANY TO MANY
-Banyak user thread dipetakan ke kernel thread
-Konkurensi optimal
-Solaris sebelum versi 9, Windows NT/2000 dengan paket
ThreadFiber
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 Speciļ¬c 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 :
1)Memudahkan koordinasi multithread seperti
proses server.
2)Tidak seboros kumpulan proses tradisional.
> Kelemahan :
1)Operasi manajemen thread sangat lebih boros.
2)Kernel harus menyediakan semua feature.
2)Thread level pemakai.
> Keunggulan :
Kinerja luar biasa bagus disbanding thread level
kernel.
1)Tidak diperlukan modifikasi kernel.
2)Fleksibelitas tinggi.
> Kelemahan :
1)Tidak manfaatkan multiprocessor.
2)Untuk aplikasi dengan keterlibatan kernel yang
kecil.
3)Mengharuskan nonblocking system call.
JENIS
THREAD BERDASARKAN WAKTU PENCIPTANYA
Kategori thread berdasarkan waktu penciptaan :
1. Static threads
Jumlah thread yang akan dibuat ditentukan saat penulisan dan kompilasi program.
Tiap thread langsung dialokasikan stack tetap.
Keunggulannya : sederhana.
Kelemahannya : tidak fleksibel.
2. 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.
REFERENCE :
