Thread Sinifi Method'larinin Kullanimi ve Uygulamalari

Aslinda her iki yontemle de ayni seyleri yapiyoruz fakat farkli iki yol kullaniyoruz. Thread sinifindan uretmis oldugumuz nesne sayesinde Thread yasam dongusundeki rolune tamamen hakim olmaktadir. Runnable ise bir arabirim gibi kullanilmaktadir. Sadece bir thread tanimlanir ve o thread uzerinde isler yurutulur fakat tum kontrole hakim olamaz. Diger onemli bir konu ise, Thread sinfindan turetilmis bir sinif icerisinde calisirken baska bir siniftan miras alamaz, cunku turetilmis bir sinif baska bir temel sinifla genisletilemez diyebiliriz. Gerekirse bunun icin Runnable arayuzu kullanilabilir. Kisacasi, eger thread'ler uzerinde calisirken thread yasam dongusune sahip tam bir kontrole ihtiyaciniz varsa thread class'inin kullanilmasi iyi bir secenek olacaktir. Eger ki, uygulamaniz icin daha fazla esnek bir yapi gerekiyor ve bunun icin diger siniflardan da yardim alinmasi gerekiyorsa, runnable arayuzunun kullanilmasi tercih edilmektedir.

Thread Sinifi Method'larinin Kullanimi ve Uygulamalari

Java Virtual Machine yapisinda bulunan Loader yani yukleyici siniflar bulunmaktadir. Bu yukleyiciler belli siniflari JVM'ye yuklerler. Thread sinifi icerisinde ClassLoader sinifinin kalitimi ile kendi sinif yukleyicilerimizi yazabiliyor ve sinif yukleme isini ozellestirebiliyoruz. Yukleme isinden kasit, siniflarin onbellege alinmasi ve sonrasinda ise yapilacak isteklere hizli bir cevap verilmesidir diyebiliriz. 

Bir dizi thread'in grup halini temsil etmektedir. Ayrica, bir thread grubu diger thread gruplarinida ayni zamanda icerebilir. Thread gruplarini bir tree seklinde dusunursek, her bir thread grubunun parent'lari haric dusunulmektedir. Bir thread kendi bulundugu thread grubuna ait tum bilgilere erisebilmesi icin izinlere sahiptir. Fakat, Parent'ta bulunan diger bir threadGroup'un veya herhangi bir threadGroup'un bilgilerine erismesi engellenmistir.

activeCount() Methodu;

Gecerli thread grubundaki aktif thread'lerin sayisini verir. Int degeri alir. public class Sample01 extends Thread{] public static void main(String[] args)    { int count = Thread.activeCount(); System.out.println("Aktif Thread'ler = " + count); }}

chechAccess() Metodu;

Calisan thread'in guvenlik izniniz oldugu muddetce sahip oldugu durumu degistirebilirsiniz. public class Sample02 extends Thread{ public void run()    { System.out.println("islemler");    } public static void main(String[] args)    { Sample02 thr1 = new Sample02(); thr1.start(); thr1.checkAccess(); System.out.println("durumunuz degistirildi"); }}

clone() Metodu;

Bir sinifin nesnesi kolonlanamaz ise bir kolon degeri olusturur. class MyThreadSinifim(){} MyThreadSinifim thr = new MyThreadSinifim ();

countStackFrame() Metodu;

Bu metodun kullanilmasi onerilmemektedir. Bu metodun kullanilmasi ile birlikte, hic bir zaman sonuclari tutarli olmamistir. Thread'ler de ki, yigin frame'lerinin sayisini tutar ve thread'i askiya alir.

currentThread() Metodu;

O anda yurutulen thread'in hangisi olduguna dair bilgi verir. public class Sample03 extends Thread{ public void run()    { System.out.println("islemler");    } public static void main(String[] args)    { Sample03 thr1 = new Sample03(); thr1.start(); System.out.println( Thread.currentThread()); }}

destroy() Metodu;

 Bu metodun kullanilmasi onerilmemektedir. Cunku bu method ile, thread'in bulundugu konumu imha ederek konum bilgisini silecektir. Sistem uzerindeki kilitlenmelerin kaynaklandigi durumlara bir sebep gosterilebilir. Bu da dondurulmus surecler yani frozen process olarak adlandirilacaktir.

dumpStack() Metodu;

Bu method sadece debugging islemlerinde kullanilmaktadir. Herhangi bir hata yakalandigi zaman, thread hangi konumdaysa oranin yigin adresi yazdirilir. public class Sample04 extends Thread { public static void main(String args[]) { Thread t = Thread.currentThread(); t.setName("My Thread"); t.setPriority(1); System.out.println("Aktif olan Thread: " + t); int active = Thread.activeCount(); System.out.println("Su an calisan Threads: " + active); Thread all[] = new Thread

; Thread.enumerate(all); for (int i = 0; i < active; i++) { System.out.println(i + ": " + all

); } Thread.dumpStack(); } }

enumerate() Metodu;

Her bir aktif thread'in calistigi konumlarda o thread'in thread grubu veya thread alt gruplarinin belirtilmis olunan bir diziye kopyalar. Bu method sadece, o an ki aktif thread'in bulundugu grubun numaralandirilmasi icin kullanilmaktadir. Eger bu method, checkAccess() methodu ile kullanilirsa thread gruplarina guvenli bir sekilde erisilebilir olacaktir. Kisacasi, thread'lerin konumlarini bir diziye almaktadir.

public class Sample05 extends Thread { public void run () { for (int i = 0; i < 20; i++) System.out.println ("i = " + i); } public static void main (String [] args) { Sample05 thr = new Sample05 (); thr.start (); Thread [] threads = new Thread

; int n = Thread.enumerate (threads); for (int i = 0; i < n; i++) System.out.println (threads

.toString ());  } }  

getAllStackTraces() Metodu;

Tum calisan thread'lerin yigindaki yerlerini listeyelebilecek bir map olusturur. Bu map'te key ve value iliskileri bulunmaktadir. Key'ler de thread'ler tutulurken, value'lar da ise StackTraceElement bilgileri tutulacaktir. Thread'lerin yigindaki yerlerine ulasabilmemiz icin getStackThread methodu kullanilabilir. Yigin konumlari, her bir thread'in sadece o anki bulundugu konumun bilgisinden oteye gidemez. Cunku her bir yigin izi, farkli zamanlarda olusturulacaktir. Egerki map sifir bilgisini gonderirse, sanal makina tarafindan bir thread'in yigin izninin olmadigi bilinecektir. public class Sample06 extends Thread { public void run() { System.out.println("This is run() method"); } public static void main(String args[]) { Sample06 trace = new Sample06(); Thread t = new Thread(trace); t.start(); Map allThreads = Thread.getAllStackTraces(); } }

getContextClassLoader() Metodu;

ClassLoader isimli bir sinifla birlikte baglantilidir. Kod calismaya basladigindan itibaren, ClassLoader'in siniflari ve kaynak kodlari yuklenmeye baslayacak ve thread'lerin ayarlanmasina yardimci olacaktir. Eger ayarlanmamissa, ClassLoader'da iliskili olan thread'ler varsayilan olarak kullanilacaktir. Uygulamanizda thread'lerin class loader sinifindan yuklenmesi icin class loader'a bagimli bir sekilde yuklenilmesi gerekiyor. ilk olarak eger bir guvenlik yonetimi varsa, ve class loader'i cagirdiginizda null degerindeyse ve class loader, ilisik oldugu sinifin aynisi degil veya atasi degilse ilisik oldugu class loader talep gonderecektir. Sonrasinda guvenlik yonetimi checkPermission metodu, RuntimePermisson("getClassLoader") izni aktif olacak sekilde cagirilir. Eger hersey tamamsa, class loader ile iliskisi saglanmistir.

setContextClassLoader(ClassLoader cl) Metodu;

ClassLoader sinifina iliskin thread'lerin ayarlari yapilir. Bir thread olusturulurken classLoader sinifi tarafindan ayarlanabilir ve thread olusturulmasina izin verildigi an calistirilan kod icin uygun bir classLoader saglandiktan sonra siniflar ve kaynaklar yuklenecektir. Ilk olarak, eger guvenlik yonetisi varsa, checkPermission metodu RuntimePermossin("setContextClassLoader") izinleri ile birlikte cagirilacaktir ve ayarlanmasi yapilacaktir.

public class Sample07 extends Thread { Thread t; Sample07() { t = new Thread(this); t.start(); } public void run() { ClassLoader c = t.getContextClassLoader(); t.setContextClassLoader(c); System.out.println("Class = " + c.getClass()); System.out.println("Parent = " + c.getParent()); } public static void main(String args[]) { new Sample07 (); } }

getDefaultUncaughtExceptionHandler() Metodu;

Bir thread birden bire farkedilmemis ozel bir durumla kesintiye ugradiginda, cagirilacak olan varsayilan isleyicidir.

setDefaultUncaughtExceptionHandler () Metodu;

Bir thread birden bire farkedilmemis ozel bir durumla kesintiye ugradiginda, cagirilacak olan varsayilan isleyicidir. Farkedilen ozel durum, bir thread tarafindan ilk olarak kontrol edilir. Sonrasinda, varsayilan yakalanmis ozel durum thread'in bulundugu threadGroup  nesnesi tarafindan kontrol edilmektedir. Eger thread, yakalanmis ozel bir durum olarak ayarlanmamissa, thread'in bulundugu threadGroup'u uncaughtException methodu uzerinde ozel olarak degismeyecektir.  Sonra, varsayilan handler'in uncaughtException methodunu cagiracaktir. Varsayilan uncaugt exception handler'i ayarlayamak, uygulamanin uncaught exception'lari ele alarak degisiklikler yapabilmemizdir. Zaten thread'ler sistem tarafindan saglanan varsayilan davranislari kabul edeceklerdir. Unutmamak gerek ki, varsayilan uncaught exception handler genellikle thread'in threadGroup nesnesini ertelemek gerektigi icin degildir, sonsuz ozyinelemelere neden olacaktir.

public class Sample08 extends Thread{ public void run() { throw new RuntimeException(); } public static void main(String[] args) { Sample08 t = new Sample08(); t.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { public void uncaughtException(Thread t, Throwable e) { System.out.println(t + " throws exception: " + e); } }); t.start(); } }

getName() Metodu;

Kullanilan thread'in ismini string tipinde veren yontemdir.

setName(String name) Metodu;

Thread'lerin isimlerini bagimsiz bir sekilde degistirebilecegimiz bir yontemdir. Arka planda, Oncelikle yine bu islem icin checkAccess metodu cagirilir ve SecurityException bilgisi gondermesine sebep olur.

getId() Metodu;

Thread'lerin konum id'lerini veren bir metoddur. Eger bir thread olusturulduysa, thread id'si pozitif bir long sayi tipinde olacaktir. Thread id'si, thread yasam dongusu icerisinde benzersiz ve asla degismeyecek olan bir ifadedir. Thread sonlandirildigi zaman, thread id bu konumu tekrardan kullanabilecektir.

public class Sample09 extends Thread { Thread t; Sample09() { t = new Thread(this, "Admin Thread"); t.setPriority(1); System.out.println("thread  = " + t); t.start(); } public void run() { System.out.println("Name = " + t.getName()); System.out.println("Id = " + t.getId()); } public static void main(String args[]) { new Sample09 (); }}

getPriority() Metodu

; Thread'in oncelik degerini int tipinde verir.

setPriority(int newPriority) Metodu;

Thread'lerin onceligini degistirebilmemiz icin gerekli set metodudur. Yine oncelikle checkAcces yontemi cagirilarak securityException 'a sebep olur. Aksi takdirde, thread'in ayari belirtilen newPriority degerinden daha kucuk olmaldir, ve thread grubundaki maksimum onceligine izin verilmelidir.

getStackTrace() Metodu;

Thread'lerin kullanmis oldugu yigin izlerinin bulundugu diziyi listeler. Bu method sifir olarak geri donus yaparsa, thread henuz calistirilmamis veya sonlandirilmis anlamina gelir. Eger dondurulen deger sifirdan farkli bir degerse, dizinin ilk elemani yiginin en ustunu temsil edecektir, ki hangi sirayla en son cagirilirsa cagrilsin farketmeyecek. Yigin listenin en altindaki sonuncu deger, en son cagirilacak yontemi temsil edecektir. Eger guvenlik yoneticisi bulundugunda, thread calismiyorsa guvenlik yoneticisi checkPermissin metodunu cagirarak runtimePermisson("getStackTrace") izni ile gorulebilecek ve gorev tamamlanacaktir. Bazi sanal makinalar, bazi durumlarda bir veya daha fazla yigin izinden yigin frame'e atlanilacaktir. Diger olaganustu bir durumsa, bir sanal makina ilgili oldugu herhangi bir thread'in yigin izin bilgisine sahip degildir, thread bu metoddan sifir bilgisini geri dondurmeye izin verecektir.

public class Sample11 extends Thread{ Sample11 thr ; public void run(){ method1(); } public static void main(String[] args) { Sample11 t = new Sample11(); t.start(); } public static void method1(){ new Sample11().method2(); } public void method2() { System.out.println(thr.currentThread().getStackTrace()<3>

.getClassName()); System.out.println(thr.currentThread().getStackTrace()<3>

.getFileName()); System.out.println(thr.currentThread().getStackTrace()<3>

.getLineNumber()); System.out.println(thr.currentThread().getStackTrace()<3>

.getMethodName());  } }

getState() Metodu;

Thread'in durum bilgisini verir. Bu metod, sistem durumunun izlenilmesi icn tasarlanmistir, senkronizasyon kontrolu icin degil.

public class Sample12 extends Thread { Sample12 thread; public void run() { Thread.State state = thread.currentThread().getState(); System.out.println(thread.currentThread().getName() + " state is - " + state); } public static void main(String[] args) { Sample12 th = new Sample12(); Sample12 th1 = new Sample12(); th.start(); try { th.sleep(1000); } catch (Exception e) { System.out.println(e); } Thread.State state = th.getState(); System.out.println(th.getName() + " state - " + state); System.out.println(th1.getName() + " state - " + th1.getState()); th1.start(); try { th1.join(); } catch (Exception e) { System.out.println(e); } System.out.println(th1.getName() + " state - " + th1.getState());   } }

Thread'in ait oldugu thread grubu bilgisini verir. Eger thread calismiyorsa yada durdurulmussa donen deger null olacaktir.

public class Sample13 extends Thread { Thread t; Sample13() { ThreadGroup tgrp = new ThreadGroup("Thread Group"); t = new Thread(tgrp, this); } public void run() { System.out.println(t.getThreadGroup()); } public static void main(String[] args) { Sample13 th = new Sample13(); th.start();       } }

Thread, exception'a yakalanmasi sebebiyle sonlandirildiginda isleyicinin vermesi gereken degeri set ederiz. Bir thread'in nasil tam kontrol edilebilir olacagi, istisna isleyicisinin almis oldugu set ayari ile istisna isleyicisinin verecegi yanit belirtilmis olur. Bu sekilde bir thread'in isleyicisi hakkinda bir set yapilmazsa, threadGroup nesnesinin bir isleyicisi gibi davranir.

public class Sample14 extends Thread { public void run() { throw new RuntimeException(); } public static void main(String[] args) { Sample14 t = new Sample14(); t.setUncaughtExceptionHandler(new demo.UncaughtExceptionHandler() { public void uncaughtException(Thread t, Throwable e) { System.out.println(t + " throws exception: " + e); } }); t.start();     } }

getUncaughtExceptionHandler() Metodu;

Thread, exception'a yakalanmasi sebebiyle sonlandirildiginda isleyicinin gonderecegi degerdir. Eger thread, thread grubundan bir nesne ise, bu thread exception tarafindan yakalanmayacaktir. Thread grup nesnesinin bilgisi geldiginde, thread durdurulmazsa thread durumu null olarak geri donecektir.

public class Sample15 extends Thread { public void run() { Thread t = new Thread(); System.out.println("Thread = " + t.getName()); Thread.UncaughtExceptionHandler handler = t.getUncaughtExceptionHandler(); System.out.println(handler); } public static void main(String[] args) { Sample15 th1 = new Sample15 (); Sample15 th2 = new Sample15 (); th1.start(); th2.start();    } }

holdsLock(Object obj) Metodu;

Sadece ve sadece gecerli thread'in belirtilen nesne uzerindeki monitor kilidini tutacaktir. Bu metod, belirli bir thread'in kilit bilgisini alip kullanilabilmesinde izin verilmesi icin tasarlinmistir.

public class Sample16 extends Thread { Thread th; public void run() { System.out.println("Holds Lock = " + Thread.holdsLock(this)); synchronized (this) { System.out.println("Holds Lock = " + Thread.holdsLock(this));         } } public static void main(String[] args) { Sample16 th = new Sample16(); th.start();      } }

interrupt() Metodu;

Interrupt kesme konusudur.  Gecerli thread, kendisini kesmedigi muddetce, her zaman calisacaktir. Thread, CheckAcces metodu'nu cagiracaktir ve securityException istisnasini atmasini saglayacaktir. Eger thread, thread sinifinda kullanilan wait(), wait(long) veya wait(long int) metodlardan bir nesne ile bloke edilirse, veya sinif icerisinde join(), join(long), join(long, int), sleep(long), veya  sleep(long, int) kullanilirsa, interrupt'in durumu temizlenecektir ve interruptedException bilgisi alinacaktir. Eger thread giris/cikis kanali uzerinde bloke edildiyse, o kanal artik kapali olacaktir. thread'in kesme durumu ayarlanacaktir ve thread ClosedByInterruptException alacaktir. Eger thread, Selector'da bloke edilirse, sonrasinda thread'in kesme durumu ayarlanacak ve secim isleminden muhtemelen sifir olmayan bir degerle hemen donecektir. Tipki, selector'un calisma metodunun cagirilmasi gibi. Egerki bu kosullardan hic biri gerceklesmezse, o zaman o thread'in kesme durumu ayarlanabilir. Kesintiye ugrayan bir thread, asla aktifligini koruyamaz ve calisamaz.

interrupted() Metodu;

Gecerli olan thread'in kesilip kesilmedigini kontrol eder. Thread'in durumu kesilmisse, thread bu metod ile temizlenebilir. Diger bir ifadeyle, Bu metod arka arkada iki kez cagirilacak olsaydi, ikinci cagirilisin sonucunda false degeri aliniyor olacakti. Yani, gecerli thread tekrardan cagirilmadigi surece, ikinci kez cagirilmadan once,  ilk cagirilisinda kesilme durumunu temizleyecektir. Thread kesintisi goz ardi edilebilir cunku, bir thread ilk kesildigi anda artik calismayacaktir ve metod sayesinde false degeri yansitilacaktir.

isInterrupted() Metodu;

Thread'in kesintiye ugrayip ugramadigi kontrol edilmistir. Thread'in kesilme durumu, bu metod tarafindan belirlenmez. Kesilen bir thread'in calisip calismadigi goz ardi edilebilir cunku, thread calismadiginda dair durumunu kesilme aninda bu metod ile false degerini vererek yansitacaktir.

public class Sample17 extends Object  implements Runnable { public void run() { try { System.out.println("in run() - about to work2()"); work2(); System.out.println("in run() - back from  work2()");      } catch (InterruptedException x) { System.out.println("in run() - interrupted in work2()"); return;      } System.out.println("in run() - doing stuff after nap"); System.out.println("in run() - leaving normally");   } public void work2() throws InterruptedException { while (true) { if (Thread.currentThread().isInterrupted()) { System.out.println("C isInterrupted()=" + Thread.currentThread().isInterrupted()); Thread.sleep(2000); System.out.println("D isInterrupted()=" + Thread.currentThread().isInterrupted())       } } } public void work() throws InterruptedException { while (true) { for (int i = 0; i < 100000; i++) { int j = i * 2; } System.out.println("A isInterrupted()=" + Thread.currentThread().isInterrupted()); if (Thread.interrupted()) { System.out.println("B isInterrupted()=" + Thread.currentThread().isInterrupted()); throw new InterruptedException();   } }   } public static void main(String[] args) { Sample17 si = new Sample17(); Thread t = new Thread(si); t.start(); try { Thread.sleep(2000); } catch (InterruptedException x) { } System.out.println("in main() - interrupting other thread"); t.interrupt(); System.out.println("in main() - leaving");   } }

isAlive() Metodu;

Thread'in halen daha calisip calismadigi kontrol ediliyor. Eger thread calisiyorsa, ya calismak icin baslatilmistir yada durdurulmamistir.

isDaemon() Metodu;

Thread, bir hasara ugramistir. calismiyorsa.

setDaemon() Metodu;

  Ya bir daemon thread'ini ya da kullanilan bir thread'i isaret eden bir metoddur. Tum daemon thread'lerinde calisan bir thread oldugunda JVM sonlanacaktir. Bu method oncelikle thread basladiktan sonra cagirilir. Bu method'la birlikte ilk kullanilacak method parametresiz bir thread'e ait checkAccess metodudur. Mevcut thread'de calistiginda ise, bir SecurtiyException sonucuna sebep olacaktir.

join() Metodu;

Calismayan thread'lerin calismasi icin harekete geciren bir yontemdir.

join(long millis) Metodu;

mills parametresi ile calismayan thread'lerin calismasi icin milisaniyede bir degerle harekete gecer.

join(long millis, int nanos) Metodu;

Calismayan bir thread'in calismasi icin her bir milisaniyede, nanosaniye'ye ozen gostererek harekete gecirecektir.

resume() Metodu;

Onerilmeyen bir yontemdir. Bu metod, yalnizca suspend() kullanimi icin varolmaktadir. Thread'in deadlock egilimli olmasindan dolayi onerilmemektedir. Ilk olarak, thread'in checkAccess metodu, argumansiz cagirilir. Mevcut thread'in sebep oldugu sonuc SecurityException'dir. Eger thread askida kalacak sekilde hala calisiyorsa, tekrar yurutulebilmesi icin izin verilir ve calismaya devam eder.  (kaldigi yerden devam edecektir.)

run() Metodu;

Ayri bir Runable calisma nesnesi kullanilarak thread calistirilmaktadir. Bu,  Runable nesnesinin run metodu bilinir. Aksi halde, bu metod alt siniflar override edilmezsse, calismayacak ve deger gondermeyecektir.

start() Metodu;

Java Virtual Machine thread'i run metodunu cagiracaktir, run metodunun baslayabilmesi icinse gerek olan komutu start metodu verecektir. Sonucta iki thread ayni anda calisiyor olabilir. Bunlar gecerli thread (start metodu ile cagirilan) ve diger thread (run metodu ile cagirilan)'dir. Bu birden fazla thread'i calistirmak icin gecerli degildir. Ozellikle, bir thread'in yurutulmesi tamamlandiktan sonra bir kereligine bile olsa yeniden baslayamaz.

sleep(long millis) Metodu;

Bu metodla, calisilan thread'in belirtilen milisaniyelerde gecici olarak durdurulmasi saglanir. Bu esnada, sistemin zamanlamasi hassasiyet ve dogruluk gostermektedir. Thread herhangi bir izleme kaybi kaybetmeyecektir.

sleep(long millis, int nanos) Metodu; Thread'lerin yurutulmesi durdurulmasi icin milisaniyenin her bir nanosaniyesine gore calismaktadir. Bu esnada, sistemin zamanlamasi hassasiyet ve dogruluk gostermektedir. Thread herhangi bir izleme kaybi kaybetmeyecektir.

public class Sample20 implements Runnable { Thread t;

public void run() { for (int i = 10; i < 13; i++) { System.out.println(Thread.currentThread().getName() + "  " + i); try { Thread.sleep(1000); } catch (Exception e) { System.out.println(e);       } }     } public static void main(String[] args) throws Exception { Thread t = new Thread(new Sample20()); t.start(); Thread t2 = new Thread(new Sample20()); t2.start(); } }

stop() Metodu;

toString() Metodu;

Bir thread'in temsili olarak string verilerini diziye alir. Bu veriler; Thread'in ismi, onceligi ve bulundugu ThreadGroup bilgileri olabilir.

suspend() Metodu; Onerilmemektedir. Sistemi direkt dogal bir sekilde kitlemeye neden olacagi icin bu yontemin kullanilmasi tercih edilmemektedir. Eger hedef thread, kritik bir sistemin kaynagindayken monitor isleminde bir kilit tutarsa, bunu askiya alacaktir. Thread bu kaynaga erisirene kadar Hedef thread devam edecektir. Eger thread, hedef thread'in gecmis girisimlerini monitor'de kilitleyecegi icin onceki kilitleme sonuclari kaybolacaktir. Bu kilitlenme genellikle, dondurulmuz (frozen process) sureclerde kendini gosterecektir. Askiya alinan thread oncelikle, checkAccess methodu tarafindna hic bir parametre kullanilmadan cagirilmaktadir. Sonuc olarak, SecurityException bilgisi alinacaktir. Eger thread hala canliysa, bu thread askiya alinmistir ve devam ettigi surece daha fazla ilerleyemeyecektir.

yield() Metodu;

Calisan bir Thread'in nesnesini gecici olarak durdurmak icin kullanilmaktadir. Ardindan diger thread'lerin calismasina olanak verecektir.

public class Sample21 implements Runnable { Thread t; Sample21(String str) { t = new Thread(this, str); t.start(); } public void run() { for (int i = 0; i < 5; i++) { if ((i % 5) == 0) { System.out.println(Thread.currentThread().getName() + " yielding control..."); Thread.yield();        } } System.out.println(Thread.currentThread().getName() + " has finished executing.");      } public static void main(String[] args) { new Sample21("Thread 1"); new Sample21("Thread 2"); new Sample21("Thread 3"); new Sample21("Thread 4");      } }

Not; Bu calisma Suleyman Demirel Universitesi – Bilgisayar Muhendisligi Bolumu, Degerli Hocamiz Ali GUNES ‘in beraberinde islenen Paralel Programlama Dersi icin hazirlanmistir.

Not; Bu calisma Suleyman Demirel Universitesi – Bilgisayar Muhendisligi Bolumu, Degerli Hocamiz Ali GUNES ‘in beraberinde islenen Paralel Programlama Dersi icin hazirlanmistir.

Keyifli Calismalar Dilerim.