Soru “Runnable uygular” ve “iş parçacığını genişletir”


Java'da hangi konulara harcadığımdan itibaren, bu iki yolla konuları yazdım:

İle implements Runnable:

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

Ya da 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 satırında önemli bir fark var mıdır?


1797
2018-02-12 14:28


Menşei


Bu soru için teşekkürler, cevaplar, sahip olduğum birçok yanlış anlaşılmayı tamamladı. Java iş parçacığının SO varlığından önce doğru şekilde yapılmasını sağladım ve orada bir sürü yanlış bilgi / güncel bilgiler vardı. - James McMahon
Thread'i genişletmek isteyebileceğiniz bir sebep var.ama bunu önermiyorum), önleyici olarak ele alabilirsiniz interrupt(). Yine, bu bir fikir, doğru durumda yararlı olabilir, ancak ben bunu önermiyorum. - bestsss
Lütfen güzelce açıklanmış cevaba bakınız: stackoverflow.com/q/5562720/285594 - YumYumYum
@bestsss, interrupt () işlemeyle ilgili ne anlama gelebileceğinizi öğrenmeye çalışıyorum. Yöntemi geçersiz kılmaya çalışıyor musunuz? - Bob Cross
yes.As koduna göre, A sınıfı, herhangi bir sınıfı uzatabilirken, Thread B sınıfı, başka bir sınıfı genişletemez. - mani deepak


Cevaplar:


Evet: uygular Runnable Bunu yapmak için tercih edilen yol, IMO. İş parçacığının davranışını gerçekten uzmanlaştırmıyorsun. Sadece koşacak bir şey veriyorsun. Bunun anlamı bileştirme, kompozisyon öyle mi kalenderce "Purer" yolu.

İçinde pratik şartlar, uygulayabileceğiniz anlamına gelir Runnable ve başka bir sınıftan da uzanabilir.


1447
2018-02-12 14:32



Tam olarak, iyi koydum. Konu içinde genişleterek hangi davranışları uzatacağız? Çoğu insanın herhangi bir davranışın üzerine yazmaya çalışmadığını, ancak Thread'in davranışını kullanmaya çalıştığını iddia ediyorum. - hooknc
Bir yan yorum olarak, bir iş parçacığı başlatırsanız ve onun start () yöntemini çağırmazsanız, Java <5'de bir bellek sızıntısı yaratırsınız (bu, Runnables ile gerçekleşmez): stackoverflow.com/questions/107823/... - Nacho Coloma
Runnable'ın bir küçük avantajı, eğer bazı durumlarda umursamıyor ya da iş parçacığı kullanmak istemiyorsanız ve sadece kodu çalıştırmak istiyorsanız, run () işlevini çağırmanız yeterlidir. Örneğin. (çok el sıkıntısı) if (numberCores > 4) myExecutor.excute(myRunnable); else myRunnable.run() - user949300
@ user949300 ile bunu da yapabilirsiniz extends Thread ve eğer diş çekme istemiyorsan neden uygularsın ki Runnable... - m0skit0
Sierra ve Bates'i açıklamak için, Runnable'ın uygulanmasının en önemli yararı, “işin” “koşucu” dan mimari olarak ayrılmasıdır. - 8bitjunkie


tl: dr: Runnable uygular. Ancak, uyarı önemli

Genel olarak, gibi bir şey kullanmanızı tavsiye ederim Runnable ziyade Thread çünkü çalışmanızı sadece eşzamanlılık seçiminizle gevşek bir şekilde birleştirmenize izin veriyor. Örneğin, Runnable ve daha sonra bunun aslında kendi başına gerekli olmadığını belirlemeye karar verin. Thread, sadece threadA.run () öğesini çağırabilirsiniz.

Uyarı: Buralarda, ham ipliklerin kullanımını şiddetle tavsiye ediyorum. Kullanımı çok tercih ederim callables ve FutureTasks (Javadoc’dan: "İptal edilebilir bir asenkron hesaplama"). Zamanaşımı, uygun iptal ve modern eşzamanlılık desteğinin iş parçacığı havuzlarının entegrasyonu, işlenmemiş iş parçacıklarından çok daha faydalıdır.

Takip et: var FutureTask inşaatçı Bu, Runnables'i kullanmanıza izin verir (eğer en rahatınız buysa) ve yine de modern eşzamanlılık araçlarının avantajlarından yararlanın. 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)

Yani, eğer onların yerini alırsak runnable seninki ile threadA, aşağıdakileri alırız:

new FutureTask<Object>(threadA, null)

Runnables'a daha yakın olmanızı sağlayan başka bir seçenek de ThreadPoolExecutor. Kullanabilirsiniz gerçekleştirmek "gelecekte verilen görev" i yürütmek için bir Runnable'dan geçme yöntemi.

Bir iş parçacığı havuzu kullanmayı denemek isterseniz, yukarıdaki kod parçası aşağıdaki gibi bir şey olur ( Executors.newCachedThreadPool () fabrika yöntemi):

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

494
2018-02-12 14:37



Bu kabul edilen cevap IMHO'dan daha iyidir. Bir şey: sahip olduğunuz kod parçacığı yürütücüyü kapatmıyor ve insanların yanlış anladıkları milyonlarca soruyu görüyorum ve her defasında bir görevi yapmak istedikleri zaman yeni bir Executor yaratıyorlar. es Statik (veya enjekte edilmiş) bir alan olarak daha iyi olurdu, böylece sadece bir kez yaratılır. - artbristol
@artbristol, teşekkürler! Yeni Executor'a katılmıyorum (kodumuzda önerdiğin şeyi yapıyoruz). Orijinal cevabı yazarken, orijinal parçaya en az düzeyde kod yazmaya çalışıyordum. Bu cevapların pek çok okuyucusunun onları atlama noktaları olarak kullandığını umuyoruz. Javadoc için bir yedek yazmaya çalışmıyorum. Bunun için pazarlama materyallerini etkili bir şekilde yazıyorum: Bu yöntemi seviyorsanız, sunmamız gereken diğer harika şeyleri görmelisiniz ...! - Bob Cross
Biliyorum, bu konu hakkında biraz yorum yapıyorum ama FutureTask doğrudan yapmak istediğiniz şey genellikle değil. ExecutorServices uygun oluşturmak Future senin için ne zaman submit bir Runnable/Callable onlara. Aynı şekilde ScheduledExecutorServices ve ScheduledFuture sen ne zaman schedule bir Runnable/Callable. - Powerlord
@Powerlord, amacım OP'leri mümkün olduğunca yakından eşleştiren kod parçaları yapmaktı. Yeni FutureTask'ın optimal olmadığına katılıyorum ama açıklama amacıyla açık. - Bob Cross


Hikayeden çıkarılacak ders:

Yalnızca bazı davranışları geçersiz kılmak istiyorsanız devralın.

Ya da daha doğrusu şöyle olmalıdır:

Daha az, daha fazla arayüz.


226
2018-03-11 15:50



Eşzamanlı çalışan bir Nesne oluşturmaya başlarsanız, bu her zaman sorun olmalıdır! Konu Nesne işlevlerine bile ihtiyacınız var mı? - Liebertee
Konudan miras alındığında, hemen hemen her zaman davranışını geçersiz kılmak ister. run() yöntem. - Warren Dew
Bir davranışını geçersiz kılmaz java.lang.Thread geçersiz kılarak run() yöntem. Bu durumda, geçersiz kılmanız gerekir. start() yöntem tahmin ediyorum. Normalde sadece java.lang.Thread yürütme engellemenizi run() yöntem. - sura2k


Pek çok iyi cevap, buna daha fazlasını eklemek istiyorum. Bu anlamaya yardımcı olacak Extending v/s Implementing Thread.
Extends, iki sınıf dosyasını çok yakından bağlar ve kodla uğraşmak için oldukça zor olabilir.

Her iki yaklaşım da aynı işi yapıyor ama bazı farklılıklar var.
En yaygın fark 

  1. Thread sınıfını genişlettiğinizde, bundan sonra istediğiniz herhangi bir sınıfı genişletemezsiniz. (Bildiğiniz gibi, Java birden fazla sınıfı devralmaya izin vermez).
  2. Runnable'ı uygularken, gelecekteki veya şimdi başka bir sınıfı genişletmek için sınıfınız için bir alan kaydedebilirsiniz.

Ancak, bir önemli fark Runnable ve genişletme iş parçacığı arasında
  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 bir şekilde anlamanıza yardımcı olur

//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 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

Runnable arabirim yaklaşımında, bir sınıfın sadece bir örneği oluşturuluyor ve farklı iş parçacıkları tarafından paylaşılıyor. Böylece her bir iplik erişimi için sayacın değeri artar.

Bununla birlikte, Thread sınıfı yaklaşımı, her iş parçacığı erişimi için ayrı bir örnek oluşturmanız gerekir. Bu nedenle, her sınıf örneği için farklı bellek ayrılır ve her birinin ayrı sayacı vardır, değer aynı kalır, yani nesne referansının hiçbiri aynı olmadığından hiçbir artış olmaz.

Runnable ne zaman kullanılır?
Aynı kaynağa iş parçacığı grubundan erişmek istediğinizde Runnable arabirimini kullanın. Burada Thread sınıfını kullanmaktan kaçının, çünkü çoklu nesne oluşturma daha fazla bellek tüketir ve büyük bir performans yükü olur.

Runnable'ı uygulayan bir sınıf bir iş parçacığı ve bir sınıf değildir. Bir Runnable'ın bir Thread olması için, bir Thread örneğini oluşturmanız ve kendisini hedef olarak iletmeniz gerekir.

Çoğu durumda, yalnızca geçersiz kılmayı planlıyorsanız Runnable arabirimi kullanılmalıdır. run() yöntem ve başka hiçbir Konu yöntemleri. Bu önemlidir, çünkü programcının sınıfın temel davranışını değiştirmeyi veya geliştirmeyi amaçlamadığı sürece, sınıflar alt sınıflanmamalıdır.

Bir üst sınıfın genişletilmesi gerektiğinde, Runnable arabirimini uygulamak, Thread sınıfını kullanmaktan daha uygundur. Çünkü bir iş parçacığı yapmak için Runnable arabirimini uygularken bir başka sınıfı da genişletebiliriz.

Umarım bu yardımcı olacak!


185
2018-03-05 14:26



Kodun patentli yanlış. Demek istediğim, ne yapar, ama göstermeyi amaçladığınız şey değil. - zEro
Açıklığa kavuşturmak için: runnable vakası için birden fazla iş parçacığı başlatmak için aynı ImplementsRunnable örneğini kullandınız. Ancak, Thread davası için, gösterdiğiniz davranışa neden olan farklı ExtendsThread örnekleri oluşturuyorsunuz. Ana yönteminizin 2. yarısı şöyle olmalıdır: ExtendsThread et = new ExtendsThread();  Thread tc1 = new Thread(et);  tc1.start();  Thread.sleep(1000);  Thread tc2 = new Thread(et);  tc2.start();  Thread.sleep(1000);  Thread tc3 = new Thread(et);  tc3.start();  Daha net mi? - zEro
Niyetinizi henüz anlamıyorum ama benim amacım, eğer ExtendsThread'in birden çok örneğini oluşturursanız - hepsi de (gösterdiğiniz gibi) 1'e dönecektir. Orada aynı şeyi yaparak, yani ImplementsRunnable'ın birden çok örneğini oluşturarak Runnable için aynı sonuçları alabilirsiniz. - zEro
@zEro Merhaba, ben gelecekten geliyorum. Kodunuzun sürümünüzün verildiği göz önüne alındığında Thread artıyor, deyim 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 sonra yanlış mı? Eğer değilse, o zaman bunu gösteren bir durum nedir? - Evil Washing Machine
@EvilWashingMachine: Uzun süre aktif değil ... ve bunu gördüm. Nesnenin hash kodunu baskı ifadelerine ekledim ... + " hashcode: " + this.hashCode() - zEro


Şaşkın olduğum bir şey henüz söz konusu değil ki uygulama Runnable sınıfınızı daha esnek hale getirir.

İş parçacığı genişletirseniz, yaptığınız eylem her zaman bir iş parçacığında olur. Ancak, eğer uygularsanız Runnable Olmak zorunda değil. Bir iş parçacığı içinde çalıştırabilir veya bir tür yürütme hizmetine iletebilir veya tek bir iş parçacığı uygulamasında bir görev olarak iletebilirsiniz (belki daha sonra, ancak aynı iş parçacığında çalıştırılabilir). Sadece kullandığınız seçenekler çok daha açık Runnable kendini bağladığından daha Thread.


73
2018-02-12 14:51



Eh, aslında aynı şeyi Thread nesne çok Thread implements Runnable… ;-) Ama "daha iyi hissediyor" bu şeylerle Runnable onları bir Thread! - siegi
Doğru ama Thread İhtiyacınız olmayan birçok şey ekler ve çoğu durumda istemez. Gerçekte yaptığınız şeyle eşleşen arayüzün uygulanması her zaman daha iyidir. - Herms


Başka bir dersi uygulamak veya genişletmek istiyorsanız o zaman Runnable Eğer genişletmek veya daha sonra uygulamak için başka bir sınıf istemiyorsanız arabirim en çok tercih edilir Thread sınıf tercih edilir

En yaygın fark

enter image description here

Sen ne zaman extends Thread Bundan sonra, ihtiyacınız olan başka bir sınıfı genişletemezsiniz. (Bildiğiniz gibi, Java birden fazla sınıfı devralmaya izin vermez).

Sen ne zaman implements RunnableSınıfınız için gelecekte veya şimdi başka bir sınıfın genişletilmesi için bir alan kaydedebilirsiniz.

  • Java, birden fazla kalıtımı desteklemez, bu da Java'da bir sınıfı genişletebileceğiniz anlamına gelir, böylece Thread sınıfını genişlettikten sonra şansınızı kaybettiniz ve Java'da başka bir sınıfı genişletemez veya devralamazsınız.

  • Nesne yönelimli programlamada, bir sınıfı genişletmek genellikle yeni işlevsellik eklemek, davranışları değiştirmek veya iyileştirmek anlamına gelir. Eğer Thread üzerinde herhangi bir değişiklik yapmıyorsak, bunun yerine Runnable arayüzünü kullanın.

  • Runnable arabirimi, düz iş parçacığı veya Yürütücüler veya herhangi bir başka yöntem tarafından yürütülebilen bir görevi temsil eder. Bu yüzden Görev, İş'ten Mantıksız olarak mantıksal olarak ayrıştırmak iyi bir tasarım kararıdır.

  • Ayrılmaz görev, Runnable olarak, görevi yeniden kullanabileceğimiz anlamına gelir ve aynı zamanda onu farklı yollarla yürütme özgürlüğüne de sahiptir. bir iş parçacığı tamamlandıktan sonra yeniden başlatamayacağınız için. tekrar Runnable vs İş için Görev, Runnable kazanır.

  • Java tasarımcısı bunu kabul eder ve bu nedenle Executors'ın Runnable'ı Görev olarak kabul etmesi ve bu görevi yürüten çalışan iş parçacığı vardır.

  • Tüm Thread yöntemlerini devralmak, sadece Runnable ile kolayca yapılabilen bir Görevi temsil etmek için ek yüklerdir.

Nezaket javarevisited.blogspot.com

Bunlar, Thread ile Runnable arasında herhangi bir farklılık fark ederseniz, Thread ile Runnable arasındaki farklardan bazılarıdır. Bu senaryo için şahsen Runnable'ı Thread üzerinden kullanıyorum ve ihtiyacınıza göre Runnable veya Callable arayüzünü kullanmanızı öneriyorum.

Ancak, önemli farktır.

Sen ne zaman extends Thread sınıfınız, her bir parçanız benzersiz bir nesne oluşturur ve onunla ilişkilendirilir. Sen ne zaman implements RunnableAynı nesneyi birden çok iş parçacığına paylaşır.


65
2018-05-11 08:59





Aslında, karşılaştırmak akıllıca değildir. Runnable ve Thread birbirleriyle.

Bu ikisinin tıpkı tıpkı tıpkı tıpkı tıpkı tıpta olduğu gibi, çok parçalı bir ilişkide bir bağımlılığı ve ilişkisi var. Wheel and Engine motorlu taşıt ilişkisi.

İki adımda çoklu iş parçacığı için tek bir yol olduğunu söyleyebilirim. Bana bahşiş vereyim.

Runnable:
Uygularken interface Runnable demek oluyor ki bir şey yaratıyorsunuz run able farklı bir iş parçacığında. Şimdi bir iş parçacığı içinde çalışabilen bir şey yaratmak (bir iş parçacığı içinde çalıştırılabilir), bir iş parçacığı oluşturmak anlamına gelmez.
Yani sınıf MyRunnable bir şey değil ama sıradan bir sınıf void run yöntem. Ve nesneler sadece bir yöntemle bazı sıradan nesneler olacak run çağrıldığında normal olarak yürütülür. (nesneyi bir iş parçacığına aktarmadıkça).

Konu:
class ThreadBen çok özel bir sınıfa başlayabilen yeni bir iplik başlatabilme özelliğine sahip çok özel bir sınıf. start() yöntem.

Neden karşılaştırmak akıllıca değil?
Çünkü her ikisine birden çok iş parçacığı için ihtiyacımız var.

Çok iş parçacığı için iki şeye ihtiyacımız var:

  • Bir iş parçacığı içinde çalışabilir bir şey (Runnable).
  • Yeni bir Konu başlatacak bir şey (Konu).

Yani teknik olarak ve teorik olarak her ikisi de bir iş parçacığı başlatmak için gereklidir. koşmak ve bir olacak koştur (Sevmek Wheel and Engine motorlu taşıtlar).

Bu yüzden bir iş parçacığı ile başlayamazsınız. MyRunnable bir örneğine iletmeniz gerekiyor Thread.

Fakat yalnızca bir iş parçacığı oluşturmak ve çalıştırmak mümkündür class Thread çünkü sınıf Thread uygular Runnable hepimiz biliyoruz Thread ayrıca bir Runnable içeride.

En sonunda Thread ve Runnable Rakip veya yedek olmayan çoklu iş parçacığı için birbirini tamamlar.


61
2018-05-12 13:50



Kesinlikle! Bu kabul edilen cevap olmalı. BTW Bence soru düzenlenmiş ve ThreadA artık anlamıyor - idelvall
kabul edilen cevap çok daha fazla delegedir. - Saif


Runnable'ı uygulamanız gerekir, ancak Java 5 veya daha yüksek bir sürümde çalışıyorsanız, new Thread ama kullan ExecutorService yerine. Ayrıntılar için bakınız: Java'da basit iş parçacığı nasıl uygulanır?.


41
2018-02-12 14:41



Tek bir iş parçacığı başlatmak istiyorsanız, ExecutorService bu yararlı olacağını düşünmüyorum. - Powerlord
Benim öğrendiklerimden biri artık kendi başına bir iş parçacığı başlatmamalı, çünkü bunu yürütücü hizmetine bırakmak, çok daha fazla kontrol edilebilir hale getiriyor (iş parçacığının askıya alınmasını beklemek gibi). Ayrıca, soruda tek bir iş parçacığı hakkında ima eden hiçbir şey göremiyorum. - Fabian Steeg
Tek bir iş parçacığı olacağını anlarsak çok iş parçacığı kullanmanın amacı nedir? Bu yüzden birden fazla iş parçacığımız olduğunu ve bu cevabın değerli olduğunu varsayalım. - zEro
@zEro Eminim ki sadece bir tane bir tane de Dispatch Thread var. Tek bir konu olduğundan şüpheliyim, ancak ayrı bir iş parçacığına sahip olmanın en iyisi, ancak birden fazla değere sahip olmanın en iyi yolu değildi. - porcoesphino


Ben uzman değilim, ama Uzatmak yerine Runnable uygulamak için tek bir neden düşünebilirsiniz. Konu: Java sadece tek bir kalıtımını destekler, böylece sadece bir sınıfı uzatabilirsiniz.

Düzenleme: Bu, başlangıçta "Bir arabirimin uygulanması daha az kaynak gerektirir" dedi. ayrıca, ama her iki şekilde de yeni bir Konu örneği oluşturmanız gerekiyor, bu yüzden bu yanlıştı.


31
2018-02-12 14:32



Koşulabilirken ağ görüşmeleri yapamıyoruz, değil mi? Android.os.NetworkOnMainThreadException sahip olduğum gibi. Ama iş parçacığı kullanarak ağ aramaları yapabilirim. Yanlışım varsa lütfen düzelt. - Nabeel Thobani
@NabeelThobani Normal Java umursamıyor, ama Android gibi geliyor. Yine de Android ile söyleyecek kadar tanıdık değilim. - Powerlord
@NabeelThobani Tabii ki yapabilirsiniz. Muhtemelen Runnable'ınızla bir Thread oluşturmuyorsunuzdur. - m0skit0


Üçü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, Javascript ve Actionscript 3'ün son zamanlardaki yoğun kullanımından biraz etkilenmiştir, ancak bu şekilde sınıfınız, oldukça belirsiz bir arayüze ihtiyaç duymaz. Runnable.


19
2017-10-25 21:41



Bu gerçekten üçüncü bir yol değil. Hala Runnable'ı uyguluyorsun, sadece isimsiz olarak yapıyorsun. - Don Roby
@Don Roby: Hangisi farklıdır. Genellikle uygun ve içeriklerini ve son yerel değişkenleri içeren sınıf / yöntemden kullanabilirsiniz. - Bart van Heukelom
Evet, uygun. - Don Roby
@BartvanHeukelom Uygun, ama farklı değil. Bunu, iç içe geçmiş herhangi bir tür, yani iç sınıflar, yerel sınıflar ve lambda ifadeleri ile yapabilirsiniz. - xehpuk


Java 8 sürümü ile artık üçüncü bir seçenek var.

Runnable bir fonksiyonel arayüzYani, bunun anlamı, lambda ifadeleri veya yöntem referansları ile oluşturulabilir.

Örneğiniz şu şekilde değiştirilebilir:

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

ya da ExecutorService ve bir yöntem referansı:

executor.execute(runner::run)

Bunlar sadece örneklerinizden daha kısa değil, aynı zamanda diğer cevaplarda belirtilen avantajların birçoğuna da sahiptir. Runnable üzerinde ThreadTek sorumluluk ve kompozisyon kullanma gibi, çünkü iş parçacığının davranışını uzmanlaşmıyorsunuz. Bu şekilde, ihtiyacınız olan tek şey bir ekstra sınıf oluşturmayı da engeller. Runnable örneklerinde olduğu gibi.


16
2017-07-29 11:24



Bu cevabın açıklaması gerekiyor. Biraz kafa karıştırdıktan sonra () -> {} birinin ihtiyaç duyduğu özel mantığı temsil etmesi gerekiyor? Yani daha iyi olduğu söylenebilir () -> { /* Code here */ }? - ToolmakerSteve
@ToolmakerSteve evet, düzenlenmiş. - Alex