Java'da ÔÇťRunnableÔÇŁ uygular vs ÔÇťThreadÔÇŁ i uzat─▒r


Al─▒nan cevaba git


Java'da konu ba┼čl─▒klar─▒ ile ge├žirdi─čim zamandan itibaren, konu yazman─▒n iki yolunu buldum:

─░le implements Runnable :

 public class MyRunnable implements Runnable {
    public void run() {
        //Code
    }
}
//Started with a "new Thread(new MyRunnable()).start()" call
 

Veya extends Thread :

 public class MyThread extends Thread {
    public MyThread() {
        super("MyThread");
    }
    public void run() {
        //Code
    }
}
//Started with a "new MyThread().start()" call
 

Bu iki kod blo─čunda ├Ânemli bir fark var m─▒?


1999









Cevap say─▒s─▒n─▒ say: 30






Evet: Runnable bunu yapman─▒n tercih edilen ┼čeklidir, IMO. ─░┼č par├žac─▒─č─▒n─▒n davran─▒┼č─▒n─▒ ger├žekten uzmanla┼čt─▒rm─▒yorsunuz. Sadece ko┼čmas─▒ i├žin bir ┼čeyler veriyorsun. Bu, kompozisyonun felsefi "daha saf" bir yol oldu─ču anlam─▒na gelir .

Gelen pratik a├ž─▒dan, bu uygulamaya anlam─▒na gelir Runnable ve ba┼čka bir s─▒n─▒ftan uzatmak de.


1597







tl; dr: Runnable'─▒n kullan─▒lmas─▒ daha iyi. Ancak, ihtar ├Ânemlidir

Genel olarak, i┼činizi yaln─▒zca e┼čzamanl─▒l─▒k se├žiminizle gev┼ček bir ┼čekilde bir arada tutman─▒za olanak tan─▒d─▒─č─▒ i├žin bunun Runnable yerine bir ┼čey kullanman─▒z─▒ ├Âneririm Thread . ├ľrne─čin, a kullan─▒rsan─▒z Runnable ve daha sonra buna karar vermeniz gerekti─čine karar verirseniz Thread , sadece threadA.run () ├Â─česini ├ža─č─▒rabilirsiniz.

Uyar─▒: Buralarda, ham Konu kullan─▒m─▒ndan kesinlikle vazge├žiyorum. Ben Callables ve FutureTasks kullan─▒m─▒n─▒ tercih ediyorum (javadoc'dan: "─░ptal edilebilir bir asenkron hesaplama"). Zaman a┼č─▒mlar─▒n─▒n entegrasyonu, uygun iptali ve modern e┼čzamanl─▒l─▒k deste─činin i┼č par├žac─▒─č─▒ birikimi benim i├žin i┼členmemi┼č konu y─▒─č─▒nlar─▒ndan ├žok daha faydal─▒.

Takip: Runnables'─▒ kullanabilmenizi sa─člayan (e─čer en rahat─▒n─▒z buysa) ve hala modern e┼čzamanl─▒l─▒k ara├žlar─▒ndan faydalanman─▒z─▒ sa─člayan bir FutureTask yap─▒c─▒ var. Javadoc'u al─▒nt─▒lamak i├žin :

Belirli bir sonuca ihtiyac─▒n─▒z yoksa, formun yap─▒lar─▒n─▒ kullanmay─▒ d├╝┼č├╝n├╝n:

 Future<?> f = new FutureTask<Object>(runnable, null)
 

Biz de─či┼čtirmek Yani, e─čer onlar─▒n runnable inizle threadA , a┼ča─č─▒dakileri olsun:

 new FutureTask<Object>(threadA, null)
 

Runnables'a daha yak─▒n olman─▒z─▒ sa─člayan bir ba┼čka se├ženek de ThreadPoolExecutor . "Verilen g├Ârev gelecekte gelecekte" y├╝r├╝t├╝lmek ├╝zere bir ├çal─▒┼čt─▒r─▒labilir'e ge├žmek i├žin execute y├Ântemini kullanabilirsiniz .

Bir i┼č par├žac─▒─č─▒ havuzu kullanmay─▒ denemek istiyorsan─▒z, yukar─▒daki kod par├žas─▒ a┼ča─č─▒daki gibi bir ┼čey olur ( Executors.newCachedThreadPool () factory y├Ântemini kullanarak ):

 ExecutorService es = Executors.newCachedThreadPool();
es.execute(new ThreadA());
 

545







Hikayeden ├ž─▒kar─▒lacak ders:

Yaln─▒zca baz─▒ davran─▒┼člar─▒ ge├žersiz k─▒lmak istiyorsan─▒z miras al─▒n.

Veya daha do─črusu:

Daha az miras, daha fazla aray├╝z.


251







Çok iyi cevaplar, bu konuda daha fazla eklemek istiyorum. Bu anlamanıza yardımcı olacaktır Extending v/s Implementing Thread .
Geni┼čletir, iki s─▒n─▒f dosyas─▒n─▒ ├žok yak─▒ndan birbirine ba─člar ve kodla ba┼ča ├ž─▒kmas─▒ biraz zor olabilir.

Her iki yakla┼č─▒m da ayn─▒ i┼či yapar ancak baz─▒ farkl─▒l─▒klar olmu┼čtur.
En yayg─▒n fark

  1. Thread s─▒n─▒f─▒n─▒ geni┼čletti─činizde, daha sonra istedi─činiz herhangi bir s─▒n─▒f─▒ geni┼čletemezsiniz. (Bildi─činiz gibi, Java birden fazla s─▒n─▒fa izin vermez).
  2. Runnable'─▒ uygulad─▒─č─▒n─▒zda, s─▒n─▒f─▒n─▒z─▒n gelecekte veya ┼čimdiki di─čer s─▒n─▒flar─▒ geni┼čletmesi i├žin yer kazanabilirsiniz.

Bununla birlikte, ├çal─▒┼čt─▒r─▒labilir ve Uygulanabilir Konuyu uygulamak aras─▒ndaki ├Ânemli bir fark ,
by extending Thread, each of your threads has a unique object associated with it, whereas implementing Runnable, many threads can share the same object instance.

A┼ča─č─▒daki ├Ârnek daha net anlaman─▒za yard─▒mc─▒ olacakt─▒r

 //Implement Runnable Interface...
 class ImplementsRunnable implements Runnable {

private int counter = 0;

public void run() {
    counter++;
    System.out.println("ImplementsRunnable : Counter : " + counter);
 }
}

//Extend Thread class...
class ExtendsThread extends Thread {

private int counter = 0;

public void run() {
    counter++;
    System.out.println("ExtendsThread : Counter : " + counter);
 }
}

//Use the above classes here in main to understand the differences more clearly...
public class ThreadVsRunnable {

public static void main(String args[]) throws Exception {
    // Multiple threads share the same object.
    ImplementsRunnable rc = new ImplementsRunnable();
    Thread t1 = new Thread(rc);
    t1.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t2 = new Thread(rc);
    t2.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t3 = new Thread(rc);
    t3.start();

    // Creating new instance for every thread access.
    ExtendsThread tc1 = new ExtendsThread();
    tc1.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    ExtendsThread tc2 = new ExtendsThread();
    tc2.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    ExtendsThread tc3 = new ExtendsThread();
    tc3.start();
 }
}
 

Yukar─▒daki program─▒n ├ž─▒kt─▒s─▒.

 ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
 

├çal─▒┼čt─▒r─▒labilir arabirim yakla┼č─▒m─▒nda, bir s─▒n─▒f─▒n yaln─▒zca bir ├Ârne─či olu┼čturulur ve farkl─▒ i┼č par├žac─▒klar─▒ taraf─▒ndan payla┼č─▒l─▒r. Bu nedenle, her bir i┼č par├žac─▒─č─▒ eri┼čimi i├žin sayac─▒n de─čeri art─▒r─▒l─▒r.

Oysa, Thread s─▒n─▒f─▒ yakla┼č─▒m─▒, her thread eri┼čimi i├žin ayr─▒ bir ├Ârnek olu┼čturman─▒z gerekir. Bu nedenle, her s─▒n─▒f ├Ârne─či i├žin farkl─▒ bellek tahsis edilir ve her biri ayr─▒ bir sayaca sahiptir, de─čer ayn─▒ kal─▒r; bu, nesne referans─▒n─▒n hi├žbiri ayn─▒ olmad─▒─č─▒ndan hi├žbir art─▒┼č olmaz.

Runnable ne zaman kullan─▒l─▒r?
─░┼č par├žac─▒─č─▒ grubundan ayn─▒ kaynaklara eri┼čmek istedi─činizde Runnable arabirimini kullan─▒n. Burada Thread s─▒n─▒f─▒n─▒ kullanmaktan ka├ž─▒n─▒n, ├ž├╝nk├╝ birden fazla nesne olu┼čturma daha fazla bellek harcar ve bu da b├╝y├╝k bir performansa neden olur.

Runnable'─▒ uygulayan bir s─▒n─▒f bir evre de─čil, sadece bir s─▒n─▒ft─▒r. Bir Runnable'─▒n bir Thread olmas─▒ i├žin, Thread'─▒n bir ├Ârne─čini yaratman─▒z ve kendisini hedef olarak ge├žirmeniz gerekir.

├ço─ču durumda, yaln─▒zca run() y├Ântemi ge├žersiz k─▒lmay─▒ planl─▒yorsan─▒z ve ba┼čka i┼č par├žac─▒─č─▒ y├Ântemi kullanm─▒yorsan─▒z, ├çal─▒┼čt─▒r─▒labilir arabirim kullan─▒lmal─▒d─▒r . Bu ├Ânemlidir, ├ž├╝nk├╝ programc─▒ s─▒n─▒f─▒n temel davran─▒┼č─▒n─▒ de─či┼čtirmeyi veya geli┼čtirmeyi d├╝┼č├╝nm├╝yorsa s─▒n─▒flar alt s─▒n─▒flanmamal─▒d─▒r.

Bir ├╝st s─▒n─▒f─▒ geni┼čletmeye ihtiya├ž duyuldu─čunda, Runnable arabiriminin uygulanmas─▒ Thread s─▒n─▒f─▒n─▒ kullanmaktan daha uygundur. ├ç├╝nk├╝, bir i┼č par├žac─▒─č─▒ yapmak i├žin Runnable arabirimini uygularken ba┼čka bir s─▒n─▒f─▒ geni┼čletebiliriz.

Umar─▒m bu yard─▒mc─▒ olacak!


216







┼×a┼č─▒rd─▒─č─▒m bir ┼čey hen├╝z s├Âylenmedi, uygulaman─▒n Runnable s─▒n─▒f─▒n─▒z─▒ daha esnek hale getirmesidir .

E─čer i┼č par├žac─▒─č─▒n─▒ uzat─▒rsan─▒z, yapt─▒─č─▒n─▒z eylem her zaman i┼č par├žac─▒─č─▒nda olacak. Ancak, uygularsan─▒z Runnable , olmas─▒ gerekmez. Bir i┼č par├žac─▒─č─▒nda ├žal─▒┼čt─▒rabilir ya da bir t├╝r y├╝r├╝t├╝c├╝ hizmetine iletebilir ya da yaln─▒zca tek bir i┼č par├žac─▒kl─▒ uygulama i├žinde bir g├Ârev olarak ge├žirebilirsiniz (belki daha sonra ├žal─▒┼čacak, ayn─▒ i┼č par├žac─▒─č─▒ i├žinde olabilir). Se├ženekler sadece Runnable kendinizi ba─člad─▒─č─▒n─▒zdan daha fazla kullan─▒yorsan─▒z ├žok daha a├ž─▒k Thread .


78







Ba┼čka bir s─▒n─▒f─▒ uygulamak veya geni┼čletmek istiyorsan─▒z, Runnable aray├╝z en ├žok tercih edilir, aksi halde, ba┼čka bir s─▒n─▒f─▒n geni┼čletilmesini veya uygulanmas─▒n─▒ istemiyorsan─▒z Thread , s─▒n─▒f tercih edilir.

En yayg─▒n fark


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

Ders yaparken extends Thread , ondan sonra istedi─čin di─čer dersleri uzatamazs─▒n. (Bildi─činiz gibi, Java birden fazla s─▒n─▒fa izin vermez).

Siz implements Runnable , s─▒n─▒f─▒n─▒z─▒n gelecekte veya ┼čimdiki di─čer s─▒n─▒flar─▒ geni┼čletmesi i├žin yer kazanabilirsiniz.

  • Java ├žoklu miras─▒ desteklemiyor, bu da yaln─▒zca Java'daki bir s─▒n─▒f─▒ uzatabilece─činiz anlam─▒na geliyor;

  • Nesneye y├Ânelik programlamada, bir s─▒n─▒f─▒ geni┼čletmek, yeni i┼člevler eklemek ve davran─▒┼člar─▒ de─či┼čtirmek veya geli┼čtirmek anlam─▒na gelir. ─░┼č par├žac─▒─č─▒nda herhangi bir de─či┼čiklik yapm─▒yorsak, bunun yerine Runnable arabirimini kullan─▒n.

  • ├çal─▒┼čt─▒r─▒labilir aray├╝z, d├╝z i┼č par├žac─▒─č─▒ veya y├╝r├╝t├╝c├╝ler veya ba┼čka herhangi bir yolla y├╝r├╝t├╝lebilen bir g├Ârevi temsil eder. G├Ârev'in ─░┼č par├žac─▒─č─▒ndan ├çal─▒┼čt─▒r─▒labilir olarak mant─▒ksal olarak ayr─▒lmas─▒ iyi bir tasar─▒m karar─▒d─▒r.

  • G├Ârevi ├çal─▒┼čt─▒r─▒labilir olarak ay─▒rmak, g├Ârevi yeniden kullanabilece─čimiz ve ayr─▒ca farkl─▒ y├Ântemlerle y├╝r├╝tme ├Âzg├╝rl├╝─č├╝ne sahip oldu─čumuz anlam─▒na gelir. tamamland─▒ktan sonra bir i┼č par├žac─▒─č─▒n─▒ yeniden ba┼člatamazs─▒n─▒z ├ž├╝nk├╝. Yine Runnable vs G├Ârev i├žin i┼č par├žac─▒─č─▒, Runnable kazan─▒r.

  • Java tasar─▒mc─▒s─▒ bunu tan─▒r ve bu nedenle Y├╝r├╝t├╝c├╝ler ├çal─▒┼čt─▒r─▒labilir'i G├Ârev olarak kabul eder ve bu g├Ârevi y├╝r├╝ten ├žal─▒┼čan i┼č par├žac─▒─č─▒ vard─▒r.

  • T├╝m Thread metodlar─▒n─▒n miras al─▒nmas─▒, sadece Runnable ile kolayca yap─▒labilecek bir G├Ârevi temsil etmek i├žin ek masraf sa─člar.

Dan Nezaket javarevisited.blogspot.com

Bunlar, Java'da Thread ile Runnable aras─▒ndaki ├Ânemli farklardan baz─▒lar─▒yd─▒. E─čer Runnable'dan Thread vs Runnable ile ilgili ba┼čka herhangi bir farkl─▒l─▒k biliyorsan─▒z, l├╝tfen yorum ile payla┼č─▒n. Bu senaryo i├žin ┼čahsen Runnable'─▒n ─░plikini kullan─▒yorum ve ihtiyac─▒n─▒za g├Âre Runnable veya Callable aray├╝z├╝n├╝ kullanman─▒z─▒ ├Âneririm.

Ancak, ├Ânemli fark.

Ne zaman size extends Thread s─▒n─▒f─▒, senin di┼čin her onunla benzersiz nesne ve orta─č─▒ olu┼čturur. Siz implements Runnable , ayn─▒ nesneyi birden ├žok i┼č par├žac─▒─č─▒na payla┼č─▒r.


73







Asl─▒nda O kar┼č─▒la┼čt─▒rmak ak─▒ll─▒ca de─čil Runnable ve Thread birbirleriyle.

Bu ikisinin Wheel and Engine motorlu ta┼č─▒tlarla olan ili┼čkisinde oldu─ču gibi ├žok di┼č a├žmada bir ba─č─▒ml─▒l─▒k ve ili┼čki vard─▒r .

─░ki ad─▒mda ├žoklu di┼č a├žman─▒n tek bir yolu oldu─čunu s├Âyleyebilirim. Bana bir ┼čey s├Âyleyeyim.

Runnable:
uygularken interface Runnable bunu sizsiniz ┼čey yaratmak demektir run able farkl─▒ bir i┼č par├žac─▒─č─▒. ┼×imdi bir i┼č par├žac─▒─č─▒ i├žinde ├žal─▒┼čabilecek bir ┼čey (bir i┼č par├žac─▒─č─▒ i├žinde ├žal─▒┼čt─▒r─▒labilir) olu┼čturmak, bir i┼č par├žac─▒─č─▒ olu┼čturmak anlam─▒na gelmez.
Yani s─▒n─▒f MyRunnable , metodlu s─▒radan bir s─▒n─▒ftan ba┼čka bir ┼čey de─čildir void run . Ve bu nesneler s─▒radan nesneler olacakt─▒r, ancak run ├ža─čr─▒ld─▒─č─▒nda normal ┼čekilde y├╝r├╝t├╝lebilen bir metot olacakt─▒r. (nesneyi bir dizgede ge├žirmedik├že).

Thread:,
class Thread Ben asl─▒nda start() y├Ântemi ile ├žoklu i┼č par├žac─▒─č─▒ sa─člayan yeni bir ─░┼č par├žac─▒─č─▒ ba┼člatabilen ├Âzel bir s─▒n─▒f diyebilirim .

Neden kar┼č─▒la┼čt─▒rmak ak─▒ll─▒ca de─čil?
├ç├╝nk├╝ ├žok i┼č par├žac─▒─č─▒ i├žin ikisine de ihtiyac─▒m─▒z var.

├çoklu i┼č par├žac─▒─č─▒ i├žin iki ┼čeye ihtiyac─▒m─▒z var:

  • Bir i┼č par├žac─▒─č─▒ i├žinde ko┼čabilecek bir ┼čey (Runnable).
  • Yeni bir Konu (Konu) ba┼člatabilecek bir ┼čey.

Yani teknik ve teorik olarak ikisi de bir i┼č par├žac─▒─č─▒ ba┼člatmak i├žin gerekli olan tek olacak ├žal─▒┼čt─▒rmak ve bir edecek ├žal─▒┼čt─▒r─▒ld─▒─č─▒ yapmak (Be─čen Wheel and Engine motorlu arac─▒n).

Bu y├╝zden bir konuya ba┼člayamazs─▒n─▒z MyRunnable bir ├Ârne─če ge├žmeniz gerekir Thread .

Ancak sadece kullanarak bir i┼č par├žac─▒─č─▒ olu┼čturmak ve ├žal─▒┼čt─▒rmak m├╝mk├╝nd├╝r, class Thread ├ž├╝nk├╝ Class Thread uygular, Runnable b├Âylece hepimizin Thread de bir Runnable i├ž oldu─čunu biliriz .

Sonunda Thread ve Runnable rakip veya de─či┼čtirme de─čil okuyuculu i├žin birbirlerini tamamlay─▒c─▒.


69


2015-05-12





Runnable'─▒ uygulamal─▒s─▒n─▒z, ancak Java 5 veya daha yeni bir s├╝r├╝mde ├žal─▒┼č─▒yorsan─▒z, bununla ba┼člamamal─▒s─▒n─▒z, bunun yerine new Thread bir ExecutorService kullanmal─▒s─▒n─▒z. Ayr─▒nt─▒lar i├žin bak─▒n─▒z: Java'da basit i┼č par├žac─▒─č─▒ nas─▒l uygulan─▒r .


44







Uzman de─čilim, fakat Runnable'─▒ uzatmak yerine Runnable'─▒ uygulamak i├žin bir neden d├╝┼č├╝nebiliyorum Konu: Java yaln─▒zca tek bir kal─▒t─▒m─▒ destekliyor, b├Âylece yaln─▒zca bir s─▒n─▒f─▒ geni┼čletebilirsiniz.

D├╝zenleme: Bu asl─▒nda "Bir aray├╝z uygulamak daha az kaynak gerektirir." Dedi. Ayr─▒ca, ancak her iki ┼čekilde de yeni bir Thread ├Ârne─či olu┼čturman─▒z gerekir, bu y├╝zden bu yanl─▒┼čt─▒.


33







├ť├ž├╝nc├╝ bir yol oldu─čunu s├Âyleyebilirim:

 public class Something {

    public void justAnotherMethod() { ... }

}

new Thread(new Runnable() {
   public void run() {
    instanceOfSomething.justAnotherMethod();
   }
}).start();
 

Belki de bu durum Javascript ve Actionscript 3'├╝n yo─čun kullan─▒m─▒ndan biraz etkilenmi┼čtir, ancak bu ┼čekilde s─▒n─▒f─▒n─▒z─▒n olduk├ža belirsiz bir aray├╝z uygulamas─▒na gerek kalmaz Runnable .


20







Java 8'in piyasaya s├╝r├╝lmesiyle birlikte, ├╝├ž├╝nc├╝ bir se├ženek var.

Runnable a, i┼člevsel bir aray├╝z bunun ├Ârnekleri lambda ifadeleri veya y├Ântem referanslarla yarat─▒labilmesidir ara├žlar.

├ľrne─činiz a┼ča─č─▒dakilerle de─či┼čtirilebilir:

 new Thread(() -> { /* Code here */ }).start()
 

ya da bir ExecutorService ve y├Ântem referans─▒ kullanmak istiyorsan─▒z :

 executor.execute(runner::run)
 

Bunlar sadece ├žok daha k─▒sa sizin ├Ârneklerden de─čil, ama ayn─▒ zamanda kullanan di─čer cevaplar belirtilen avantajlar─▒n bir├žok ile gelen Runnable ├╝zerinde Thread b├Âyle tek sorumluluk ve par├žac─▒─č─▒n─▒n davran─▒┼č─▒n─▒ uzmanla┼čm─▒┼č de─čil ├ž├╝nk├╝ kompozisyon kullanmak gibi. Bu ┼čekilde, ihtiyac─▒n─▒z olan Runnable tek ┼čey ├Ârneklerde yapt─▒─č─▒n─▒z gibi ise, ekstra bir s─▒n─▒f olu┼čturmaktan da ka├ž─▒n─▒r .


18


2014-07-29





Bir arabirim olu┼čturmak, kodunuz ve i┼č par├žac─▒─č─▒ uygulamas─▒ aras─▒nda daha temiz bir ayr─▒m sa─člar, bu nedenle bu durumda Runnable'─▒ uygulamay─▒ tercih ederim.


16







Buradaki herkes Runnable'─▒ uygulaman─▒n gitmenin bir yolu oldu─čunu ve onlarla ger├žekten ayn─▒ fikirde olmad─▒─č─▒m─▒ d├╝┼č├╝n├╝yor gibi g├Âr├╝n├╝yor ama ayn─▒ zamanda kendi kodunuzda kan─▒tlad─▒─č─▒n─▒z─▒ d├╝┼č├╝n├╝yorum.

Runnable'─▒ uygularsan─▒z, Runnable'─▒ uygulayan s─▒n─▒f, i┼č par├žac─▒─č─▒ ad─▒ ├╝zerinde denetime sahip olmazsa, i┼č par├žac─▒─č─▒ ad─▒n─▒ ayarlayabilen ├ža─č─▒ran koddur.

 new Thread(myRunnable,"WhateverNameiFeelLike");
 

fakat e─čer Thread'─▒ geni┼čletirseniz, bunu s─▒n─▒f─▒n kendi i├žinde y├Ânetebilirsiniz (├Ârnekte oldu─ču gibi 'threadB' ismini yazars─▒n─▒z). Bu durumda siz:

A) hata ay─▒klama amac─▒yla daha faydal─▒ bir ad verebilir.

B) bu ismin o s─▒n─▒f─▒n b├╝t├╝n ├Ârnekleri i├žin kullan─▒lmas─▒n─▒ zorluyor (bir konu oldu─ču ger├že─čini g├Ârmezden gelmezseniz ve yukar─▒dakileri bir ├çal─▒┼čt─▒r─▒labilirmi┼č gibi yap─▒n. Ancak burada kongre hakk─▒nda konu┼čuyoruz. hissetti─čim bu olas─▒l─▒─č─▒ g├Âz ard─▒ et.

├ľrne─čin, yarat─▒l─▒┼č─▒ hakk─▒nda bir y─▒─č─▒n iz bile alabilir ve bunu i┼č par├žac─▒─č─▒ ad─▒ olarak kullanabilirsiniz. Bu garip g├Âr├╝nebilir ancak kodunuzun nas─▒l yap─▒land─▒r─▒ld─▒─č─▒na ba─čl─▒ olarak hata ay─▒klama ama├žlar─▒ i├žin ├žok yararl─▒ olabilir.

Bu k├╝├ž├╝k bir ┼čey gibi g├Âz├╝kebilir, ancak ├žok fazla i┼č par├žac─▒─č─▒ olan ├žok karma┼č─▒k bir uygulaman─▒z ve birden bire durdurulan anlar─▒n t├╝m├╝ (ya kilitlenme nedeniyle ya da muhtemelen daha az olabilecek bir a─č protokol├╝ndeki bir kusur nedeniyle) bariz - ya da di─čer sonsuz sebepler) o zaman Java'dan b├╝t├╝n i┼č par├žac─▒klar─▒n─▒n '─░┼č par├žac─▒─č─▒-1', '─░┼č par├žac─▒─č─▒-2', '─░┼č par├žac─▒─č─▒-3' olarak adland─▒r─▒ld─▒─č─▒ bir y─▒─č─▒n d├Âk├╝m├╝ almak her zaman ├žok i┼če yaramaz yap─▒land─▒r─▒lm─▒┼č ve hangilerinin sadece y─▒─č─▒n izleri ile hangisinin hangisi oldu─čunu s├Âyleyip s├Âyleyemeyece─činize karar verip vermeyebilirsiniz - hepsi ayn─▒ kodu ├žal─▒┼čt─▒ran birden fazla iplik grubunu kullan─▒yorsan─▒z her zaman m├╝mk├╝n de─čildir).

Tabii ki, ayn─▒ zamanda, ad─▒n─▒ olu┼čturma ├ža─čr─▒s─▒n─▒n y─▒─č─▒n izlemesine ayarlayan thread s─▒n─▒f─▒n─▒n bir uzant─▒s─▒n─▒ olu┼čturarak genel olarak da yapabilece─činizi ve ard─▒ndan standart java Thread s─▒n─▒f─▒ yerine Runnable uygulamalar─▒n─▒zla kullanabilece─činizi s├Âylemi┼čtiniz. (a┼ča─č─▒ya bak─▒n─▒z) ancak y─▒─č─▒n izlemesine ek olarak, hata ay─▒klama i├žin i┼č par├žac─▒─č─▒ ad─▒nda yararl─▒ olabilecek daha fazla i├žeri─če ├Âzg├╝ bilgi olabilir (├Ârne─čin, bu durumda i┼čleyebilece─či bir├žok s─▒ra veya soketten birine referans) Konuya ├Âzel olarak geni┼čletmek i├žin derleyicinin, sizi (veya kitapl─▒klar─▒n─▒ kullanan di─čerlerini) belirli bilgileri (├Ârne─čin, s├Âz konusu s─▒ra / soketi) ad─▒nda kullanmaya zorlamas─▒n─▒ sa─člayabilmeniz i├žin.

─░┼čte ├ža─č─▒ran y─▒─č─▒n izinin ad─▒yla birlikte genel i┼č par├žac─▒─č─▒na bir ├Ârnek:

 public class DebuggableThread extends Thread {
    private static String getStackTrace(String name) {
        Throwable t= new Throwable("DebuggableThread-"+name);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(os);
        t.printStackTrace(ps);
        return os.toString();
    }

    public DebuggableThread(String name) {
        super(getStackTrace(name));
    }

    public static void main(String[] args) throws Exception {
        System.out.println(new Thread());
        System.out.println(new DebuggableThread("MainTest"));
    }
}
 

ve i┼čte iki ismi kar┼č─▒la┼čt─▒ran ├ž─▒kt─▒n─▒n bir ├Ârne─či:

 Thread[Thread-1,5,main]
Thread[java.lang.Throwable: DebuggableThread-MainTest
    at DebuggableThread.getStackTrace(DebuggableThread.java:6)
    at DebuggableThread.<init>(DebuggableThread.java:14)
    at DebuggableThread.main(DebuggableThread.java:19)
,5,main]
 

12







├çal─▒┼čt─▒r─▒labilir ├ž├╝nk├╝:

  • ├çal─▒┼čt─▒r─▒labilir uygulaman─▒n ba┼čka bir s─▒n─▒f─▒ geni┼čletmesi i├žin daha fazla esneklik b─▒rak─▒r
  • Kodu y├╝r├╝tmeden ay─▒r─▒r
  • ├çal─▒┼čt─▒r─▒labilir durumunuzu bir ─░┼č par├žac─▒─č─▒ Havuzu'ndan, etkinlik i┼č par├žac─▒─č─▒ndan veya gelecekte herhangi bir ┼čekilde ├žal─▒┼čt─▒rman─▒za izin verir.

Bunlar─▒n hi├žbirine ┼čimdi ihtiyac─▒n olmasa bile, gelecekte olabilir. ─░┼č par├žac─▒─č─▒n─▒ ge├žersiz k─▒lma yarar─▒ olmad─▒─č─▒ i├žin, Runnable daha iyi bir ├ž├Âz├╝md├╝r.


11


2010-05-07





Bu ├žok pop├╝ler bir konu oldu─čundan ve iyi cevaplar her yere yay─▒ld─▒─č─▒ndan ve derinlemesine ele al─▒nd─▒─č─▒ndan, yeni cevap verenlerin di─čerlerinden gelen iyi cevaplar─▒ daha ├Âzl├╝ bir bi├žimde derlemenin hakl─▒ oldu─čunu hissettim, bu nedenle yeni gelenlerin daha kolay bir bak─▒┼č a├ž─▒s─▒ var:

  1. ─░┼člevsellik eklemek veya de─či┼čtirmek i├žin genellikle bir s─▒n─▒f─▒ geni┼čletirsiniz. Yani, sen istemiyorsan i├žin ├╝zerine herhangi Konu davran─▒┼č─▒ , ard─▒ndan Runnable kullan─▒n.

  2. Ayn─▒ ─▒┼č─▒─č─▒nda, ihtiyac─▒n─▒z yoksa hi├ž devral─▒r iplik y├Ântemlerle, bunu yapmadan yapabilirsiniz y├╝k├╝ Runnable kullanarak.

  3. Tek devralma : E─čer Thread'─▒ uzat─▒rsan─▒z, ba┼čka bir s─▒n─▒ftan uzatamazs─▒n─▒z, bu y├╝zden yapman─▒z gereken buysa, Runnable kullanman─▒z gerekir.

  4. O anlamda bir Runnable g├Ârevi olmas─▒ daha iyidir, teknik ara├žlarla ayr─▒ alan─▒ mant─▒─č─▒na iyi tasar─▒m izole sizin gelen g├Ârevi sizin ko┼čucu .

  5. ┼×unlar─▒ yapabilirsiniz y├╝r├╝tmek ayn─▒ Runnable nesne birden ├žok kez sadece bir kez ba┼člat─▒labilir, ancak, bir i┼č par├žac─▒─č─▒ bir nesneye. (Belki de nedeni, neden ├çal─▒┼čt─▒r─▒c─▒lar─▒n ├çal─▒┼čt─▒r─▒labilirleri kabul etseler ki, Konu'lar─▒ de─čil).

  6. G├Ârevinizi ├çal─▒┼čt─▒r─▒labilir olarak geli┼čtirirseniz, ┼čimdi ve gelecekte nas─▒l kullan─▒laca─č─▒ konusunda t├╝m esnekli─če sahip olursunuz . Y├╝r├╝t├╝c├╝ler ile ayn─▒ zamanda Thread ile ayn─▒ anda ├žal─▒┼čmas─▒n─▒ sa─člayabilirsiniz. Ayr─▒ca, ayn─▒ i┼č par├žac─▒─č─▒ i├žinde ayn─▒ anda ba┼čka herhangi bir s─▒radan t├╝r / nesne olarak da kullanabilirsiniz.

  7. Bu kadar da kolayla┼čt─▒r─▒r ayr─▒ g├Ârev mant─▒k ve e┼čzamanl─▒l─▒k i├žinde y├Ânleriyle sizin birim testler .

  8. Bu soru ile ilgileniyorsan─▒z, Callable ile Runnable aras─▒ndaki farkla da ilgilenebilirsiniz .


11







─░┼č par├žac─▒─č─▒n─▒ uzatma ve ├žal─▒┼čt─▒r─▒labilir uygulama aras─▒ndaki fark ┼čunlard─▒r:


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin


10







Bu Oracle'─▒n bir Konu Tan─▒mlama ve Ba┼člatma k─▒lavuzunda a├ž─▒klanm─▒┼čt─▒r:

Bu deyimlerden hangisini kullanmal─▒s─▒n? Runnable nesnesi kullanan ilk deyim daha geneldir, ├ž├╝nk├╝ Runnable nesnesi Thread d─▒┼č─▒ndaki bir s─▒n─▒f─▒ alt s─▒n─▒fland─▒rabilir. ─░kinci deyimin basit uygulamalarda kullan─▒m─▒ daha kolayd─▒r, ancak g├Ârev s─▒n─▒f─▒n─▒z─▒n Thread'─▒n soyundan olmas─▒ gerekti─či ile s─▒n─▒rl─▒d─▒r. Bu ders, ├çal─▒┼čt─▒r─▒labilir g├Ârevi, g├Ârevi y├╝r├╝ten Thread nesnesinden ay─▒ran ilk yakla┼č─▒ma odaklan─▒r. Bu yakla┼č─▒m sadece daha esnek olmakla kalmay─▒p, daha sonra ele al─▒nan ├╝st d├╝zey i┼č par├žac─▒─č─▒ y├Ânetimi API'leri i├žin de ge├žerlidir.

Ba┼čka bir deyi┼čle, uygulama Runnable , s─▒n─▒f─▒n─▒z─▒n ba┼čka bir s─▒n─▒f─▒ geni┼čletti─či senaryolarda ├žal─▒┼čacakt─▒r Thread . Java, ├žoklu miras─▒ desteklemiyor. Ayr─▒ca, Thread baz─▒ ├╝st d├╝zey i┼č par├žac─▒─č─▒ y├Ânetimi API'lerini kullan─▒rken geni┼čletme m├╝mk├╝n olmayacakt─▒r. Geni┼čletmenin Thread tercih edilebilece─či tek senaryo , gelecekte g├╝ncellemelere tabi olmayacak k├╝├ž├╝k bir uygulamadad─▒r. Runnable Projeniz b├╝y├╝d├╝k├že daha esnek oldu─ču i├žin uygulanmas─▒ neredeyse her zaman daha iyidir . Java'da bir├žok aray├╝z├╝ uygulayabilece─činizden ancak yaln─▒zca bir s─▒n─▒f─▒ geni┼čletebildi─činiz i├žin tasar─▒m de─či┼čikli─činin b├╝y├╝k bir etkisi olmaz.


8







Yan─▒lm─▒yorsam, a┼ča─č─▒ yukar─▒ benzer

Bir aray├╝z ile soyut s─▒n─▒f aras─▒ndaki fark nedir?

" A m─▒ " ili┼čkisi kurar ve ara y├╝z " Has " yetene─či sa─člar.

Tercih edilen Runnable uygular :

  1. Thread s─▒n─▒f─▒n─▒ geni┼čletmek ve Thread API varsay─▒lan uygulamas─▒n─▒ de─či┼čtirmek zorunda de─čilseniz
  2. Bir yang─▒n ve unut komutu ├žal─▒┼čt─▒r─▒yorsan─▒z
  3. Zaten ba┼čka bir s─▒n─▒fa geni┼čletiyorsan─▒z

"─░┼č par├žac─▒─č─▒n─▒ uzat" tercihini :

  1. Oracle Dok├╝man sayfas─▒nda listelenen bu Konu y├Ântemlerinden herhangi birini ge├žersiz k─▒lman─▒z gerekiyorsa

Genellikle Thread davran─▒┼č─▒n─▒ ge├žersiz k─▒lman─▒za gerek yoktur. Bu y├╝zden Runnable'─▒ ├žo─ču zaman tercih eder.

Farkl─▒ bir notta, advanced ExecutorService veya ThreadPoolExecutorService API kullanarak daha fazla esneklik ve kontrol sa─člar.

┼×u SE soruya bir g├Âz at─▒n:

ExecutorService vs Casual Thread Spawner


7







En basit a├ž─▒klama, uygulayarak Runnable ayn─▒ nesneyi birden fazla i┼č par├žac─▒─č─▒na atayabiliriz ve her biri Thread ayn─▒ nesne durumlar─▒n─▒ ve davran─▒┼č─▒n─▒ payla┼č─▒r.

├ľrne─čin, iki i┼č par├žac─▒─č─▒ oldu─čunu varsayal─▒m, thread1 diziye bir tamsay─▒ koyar ve thread2 dizi dolduruldu─čunda dizgeden tamsay─▒lar─▒ al─▒r. S─▒rayla s├Âz konusu Bildirimi thread2 onu i┼če, ister dizinin durumunu bilmesi gerekir thread1 o doldurdu veya edilmemi┼čtir.

Uygulama Runnable , nesneyi payla┼čmak i├žin bu esnekli─če sahip olman─▒za izin verirken extends Thread , her i┼č par├žac─▒─č─▒ i├žin yeni nesneler olu┼čturman─▒z─▒ sa─člar ; bu nedenle, thread1 taraf─▒ndan yap─▒lan herhangi bir g├╝ncelleme thread2'ye kaybedilir.


6







Thread s─▒n─▒f─▒n─▒n Runnable uygulamas─▒ndan ayr─▒lmas─▒, thread ve run () metodu aras─▒ndaki potansiyel senkronizasyon problemlerini de ├Ânler. Ayr─▒ bir Runnable genellikle ├žal─▒┼čt─▒r─▒labilir kodun referans g├Âsterilmesi ve y├╝r├╝t├╝lmesi konusunda daha fazla esneklik sa─člar.


5







Budur S ait KATI Tek sorumlulu─ču:.

Bir iplik temsil ├žal─▒┼čan i├žeri─či aras─▒nda: (y─▒─č─▒n ├žer├ževesi, iplik kimli─či, vs. ├žal─▒┼čma ba─člam─▒nda gibi) senkronize olmayan i┼člemler bir kod par├žas─▒ aras─▒nda. Bu kod par├žas─▒ ideal olarak ister senkron ister asenkron olsun ayn─▒ uygulama olmal─▒d─▒r .

Bunlar─▒ bir uygulamada toparlarsan─▒z, sonu├žtaki nesneye ilgisiz iki de─či┼čim nedeni verirsiniz :

  1. uygulaman─▒zda i┼č par├žac─▒─č─▒ i┼čleme (├Âr. y├╝r├╝tme ba─člam─▒n─▒ sorgulama ve de─či┼čtirme)
  2. kod par├žas─▒ taraf─▒ndan uygulanan algoritma (├žal─▒┼čt─▒r─▒labilir k─▒s─▒m)

Kulland─▒─č─▒n─▒z dil k─▒smi s─▒n─▒flar─▒ veya ├žoklu miras─▒ destekliyorsa, her bir nedeni kendi s├╝per s─▒n─▒f─▒nda ay─▒rabilirsiniz, ancak ├Âzellik k├╝meleri ├žak─▒┼čmad─▒─č─▒ndan, iki nesneyi birle┼čtirmekle ayn─▒ seviyeye gelebilir. Teori i├žin bu.

Uygulamada, genel olarak konu┼čursak, bir program─▒n gerekenden daha fazla karma┼č─▒kl─▒k ta┼č─▒mas─▒na gerek yoktur. Belirli bir g├Ârev ├╝zerinde ├žal─▒┼čan bir i┼č par├žac─▒─č─▒n─▒z varsa, bu g├Ârevi hi├ž de─či┼čtirmeden, muhtemelen g├Ârevleri ayr─▒ s─▒n─▒flar yapman─▒n bir anlam─▒ yoktur ve kodunuz daha basit kal─▒r.

Java ba─člam─▒nda , tesis zaten orada oldu─čundan , do─črudan ba─č─▒ms─▒z Runnable s─▒n─▒flardan ba┼člamak ve ├Ârneklerini Thread (veya Executor ) ├Ârneklerine aktarmak daha kolayd─▒r . Bir kez bu paternde kullan─▒ld─▒─č─▒nda , basit ├žal─▒┼čt─▒r─▒labilir iplik k─▒l─▒f─▒ndan daha kullanmak (veya hatta okumak) zor de─čildir.


5







Bir temel s─▒n─▒f─▒ geni┼čletmek yerine bir arabirim uygulamak istemenizin bir nedeni, zaten ba┼čka bir s─▒n─▒fa geni┼čletiyor olman─▒zd─▒r. Yaln─▒zca bir s─▒n─▒f─▒ uzatabilirsiniz, ancak istedi─činiz say─▒da arabirim uygulayabilirsiniz.

─░┼č par├žac─▒─č─▒n─▒ geni┼čletirseniz, temel olarak mant─▒─č─▒n─▒z─▒n 'this' d─▒┼č─▒ndaki herhangi bir i┼č par├žac─▒─č─▒ taraf─▒ndan y├╝r├╝t├╝lmesini ├Ânl├╝yorsunuz. Mant─▒─č─▒n─▒z─▒ y├╝r├╝tmek i├žin yaln─▒zca bir i┼č par├žac─▒─č─▒ istiyorsan─▒z , yaln─▒zca Runnable'─▒ uygulamak daha iyidir.


5







runnable kullan─▒yorsan─▒z, di─čer s─▒n─▒f─▒n─▒za geni┼čletmek i├žin alan kazanabilirsiniz.


5







S─▒n─▒f─▒m─▒z─▒n bir davran─▒┼č g├Âstermesini istedi─čimiz temel nedeni tekrar ziyaret edebilir miyiz Thread ? Hi├ž bir neden yok, biz sadece asenkron modda bir g├Ârevi y├╝r├╝tmek istedik, bu tam olarak g├Ârevin yerine getirilmesinin erken biterse ana i┼č par├žac─▒─č─▒m─▒zdan ve ana i┼č par├žac─▒─č─▒ndan dallanmas─▒ gerekti─či anlam─▒na gelir. dall─▒ yol i├žin (g├Ârev).

E─čer b├╝t├╝n ama├ž buysa, o zaman ├Âzel bir Konuya olan ihtiyac─▒m─▒ nerede g├Âr├╝yorum. Bu, Sistem ─░plik Havuzundan bir RAW ─░plik alarak ve g├Ârevimize atayarak (s─▒n─▒f─▒m─▒z─▒n bir ├Ârne─či olabilir) ger├žekle┼čtirilebilir.

O halde, OOP kavram─▒na uyal─▒m ve ihtiyac─▒m─▒z olan t├╝rde bir s─▒n─▒f yazal─▒m. Bir ┼čeyleri yapman─▒n, do─čru ┼čekilde yapman─▒n bir├žok yolu vard─▒r.

Bir g├Âreve ihtiyac─▒m─▒z var, o y├╝zden bir i┼č par├žac─▒─č─▒nda ├žal─▒┼čt─▒r─▒labilecek bir g├Ârev tan─▒m─▒ yaz─▒n. Yani Runnable kullan─▒n.

Her zaman hat─▒rla implements , bir davran─▒┼č vermek i├žin ├Âzel olarak kullan─▒l─▒r ve extends bir ├Âzellik / ├Âzellik kazand─▒rmak i├žin kullan─▒l─▒r.

─░┼č par├žac─▒─č─▒n─▒n ├Âzelli─čini istemiyoruz, bunun yerine s─▒n─▒f─▒m─▒z─▒n ├žal─▒┼čt─▒r─▒labilecek bir g├Ârev olarak davranmas─▒n─▒ istiyoruz.


5







Evet, ThreadA ├ža─čr─▒s─▒n─▒ ├ža─č─▒r─▒rsan─▒z, start y├Ântemini ├ža─č─▒rman─▒za gerek yoktur ve ├žal─▒┼čt─▒rma y├Ântemi yaln─▒zca ThreadA s─▒n─▒f─▒n─▒ ├ža─č─▒rd─▒ktan sonra ├ža─č─▒r─▒l─▒r. Ancak ThreadB ├ža─čr─▒s─▒n─▒ kullan─▒rsan─▒z, ├ža─čr─▒ ├žal─▒┼čt─▒rma y├Ântemi i├žin ba┼člang─▒├ž ÔÇőÔÇői┼č par├žac─▒─č─▒ gerekli olmal─▒d─▒r. Daha fazla yard─▒m─▒n varsa, cevap ver.


4







Bahsedilen t├╝m nedenlerden dolay─▒ Runnable'─▒ kullanman─▒n en kullan─▒┼čl─▒ oldu─čunu d├╝┼č├╝n├╝yorum, ancak bazen kendi i┼č par├žac─▒─č─▒ durdurma y├Ântemimi olu┼čturabilir ve do─črudan olu┼čturdu─čum i┼č par├žac─▒─č─▒ ├╝zerinde arayabilirim.


4







Java ├žoklu miras─▒ desteklememektedir, bu nedenle Thread s─▒n─▒f─▒n─▒ geni┼čletirseniz, ba┼čka bir s─▒n─▒f geni┼čletilmez.

├ľrne─čin: Bir applet olu┼čturursan─▒z, Applet s─▒n─▒f─▒n─▒ geni┼čletmesi gerekir, bu y├╝zden burada thread olu┼čturman─▒n tek yolu Runnable arabirimini uygulamakt─▒r.


4







Runnable bir aray├╝z iken Thread , bu aray├╝z├╝ uygulayan bir s─▒n─▒ft─▒r. Tasar─▒m a├ž─▒s─▒ndan, bir g├Ârevin nas─▒l tan─▒mland─▒─č─▒ ve nas─▒l y├╝r├╝t├╝ld├╝─č├╝ aras─▒nda net bir ayr─▒m yap─▒lmal─▒d─▒r. ─░lki, bir Runnalbe uygulaman─▒n sorumlulu─čundad─▒r ve ikincisi Thread s─▒n─▒f─▒n i┼čidir . ├ço─ču durumda uygulama Runnable takip etmek i├žin do─čru yoldur.


4







Thread ile runnable aras─▒ndaki fark. Thread s─▒n─▒f─▒n─▒ kullanarak Thread yarat─▒yorsak, yaratt─▒─č─▒m─▒z nesne say─▒s─▒na e┼čit olan Thread say─▒s─▒. E─čer runnable aray├╝z├╝n├╝ uygulayarak thread yarat─▒yorsak, o zaman birden fazla thread olu┼čturmak i├žin tek bir nesne kullanabiliriz. Tek bir nesne birden fazla Thread taraf─▒ndan payla┼č─▒l─▒r.

Yani bizim verim senstive de─čilse ihtiyac─▒na ba─čl─▒ olarak. B├Âylece Runnable aray├╝z├╝n├╝ kullanabilece─čimiz birden fazla Thread aras─▒nda payla┼č─▒labilir.


4







Buraya iki kuru┼č ekleyerek - Her zaman m├╝mk├╝n oldu─čunda kullan─▒n implements Runnable . A┼ča─č─▒da neden extends Thread s kullanmaman─▒z gerekti─čine dair iki uyar─▒ var

  1. ─░deal olarak, Thread s─▒n─▒f─▒n─▒ asla geni┼čletmemelisiniz; Thread s─▒n─▒f yap─▒lmal─▒d─▒r final . En az─▒ndan y├Ântemleri gibi thread.getId() . S uzatma ile ilgili bir hata i├žin bu tart─▒┼čmaya bak─▒n─▒z Thread .

  2. Bulmacalar─▒ ├ž├Âzmek isteyenler, Thread'─▒ geni┼čletmenin ba┼čka bir yan etkisini g├Ârebilirler. A┼ča─č─▒daki kod, kimse bildirmedi─činde ula┼č─▒lamaz kodu yazd─▒r─▒r.

L├╝tfen http://pastebin.com/BjKNNs2G adresini ziyaret edin .

 public class WaitPuzzle {

    public static void main(String[] args) throws InterruptedException {
        DoNothing doNothing = new DoNothing();
        new WaitForever(doNothing).start();
        new WaitForever(doNothing).start();
        new WaitForever(doNothing).start();
        Thread.sleep(100);
        doNothing.start();
        while(true) {
            Thread.sleep(10);
        }
    }


    static class WaitForever extends  Thread {

        private DoNothing doNothing;

        public WaitForever(DoNothing doNothing) {
            this.doNothing =  doNothing;
        }

        @Override
        public void run() {
            synchronized (doNothing) {
                try {
                    doNothing.wait(); // will wait forever here as nobody notifies here
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Unreachable Code");
            }
        }
    }

    static class DoNothing extends Thread {

        @Override
        public void run() {
            System.out.println("Do Nothing ");
        }
    } 
}
 

4



─░lgili yay─▒nlar


Java'da daemon thread nedir?

<? Aras─▒ndaki fark S├╝per T> ve <? T> 'yi Java' da geni┼čletir [├žo─čalt]

JavaÔÇÖdaki i┼čaretli ve denetlenmeyen istisnalar─▒ anlama

List yaz─▒n vs Java ArrayList yaz─▒n

Java'daki Runnable ve Callable arabirimleri aras─▒ndaki fark

Java'da bir i┼č par├žac─▒─č─▒n─▒ nas─▒l ├Âld├╝r├╝rs├╝n?

Konu Java'da nas─▒l d├╝zg├╝n bir ┼čekilde durdurulur?

Java'da ek a├ž─▒klamalar─▒ geni┼čletmek neden m├╝mk├╝n de─čil?

Singleton'─▒ bir Enum ile uygulama (Java'da)

Java EE konteynerindeki yumurtlama iplikleri neden ├Ânerilmiyor?

Etiketle ilgili di─čer sorular [java]


Bir ├Â─čenin JavaScript dizisinde olup olmad─▒─č─▒n─▒ bulman─▒n en iyi yolu? [├žift]

Bir fonksiyonun i├žinde de─či┼čtirdikten sonra de─či┼čkenim neden de─či┼čmiyor? - Asenkron kod referans─▒

Geri arama i┼člevi nedir?

Grep, yaln─▒zca arama d├╝zeniyle e┼čle┼čen kelimeleri g├Âsterebilir mi?

Merakl─▒ null birle┼čtirici i┼čleci ├Âzel ├Ârt├╝l├╝ d├Ân├╝┼čt├╝rme davran─▒┼č─▒

Git ile b├╝y├╝k ikili dosyalar─▒ y├Ânetme

SE├çENEKLER iste─či neden g├Ânderiliyor ve devre d─▒┼č─▒ b─▒rakabilir miyim?

Sql sunucusundaki sat─▒rlar─▒ verimli bir ┼čekilde s├╝tunlara d├Ân├╝┼čt├╝rme

Postgres DB B├╝y├╝kl├╝─č├╝ Komutanl─▒─č─▒

Hata "adb ile ba─člant─▒ koptu ve ciddi bir hata olu┼čtu."