Java'da Çok Dişli Kod Yazmanın 4 Yöntemi

Çoklu iş parçacığı işleri paralel olarak yürütmek için kod yazma yöntemidir. Java, Java 1.0'ın ilk günlerinden bu yana çok iş parçacıklı kod yazma konusunda mükemmel bir desteğe sahipti. Java'daki son gelişmeler, Java programlarına çoklu iş parçacığı eklemek için kodun yapılandırılma yöntemlerini artırdı.

Bu yazıda, bu seçeneklerden birkaçını karşılaştırdık, böylece bir sonraki Java projeciniz için hangi seçeneği kullanacağınızı daha iyi değerlendirebilirsiniz. 4 Sebep Neden Kodunuzu BitBucket Love GitHub'da Sunmalısınız? 4 Neden Kodunuzu BitBucket'te Barınmalısınız? Kodunuzu nereye koyacağınızı düşünmeniz gerekir. GitHub'ı duymuşsundur. Bu şaşırtıcı değil. GitHub bireyler ve kuruluşlar tarafından kod barındırmak, belgeler üzerinde işbirliği yapmak için kullanılır….

Yöntem 1: Thread sınıfını genişletme

Java bir sağlar iplik uygulamak için genişletilebilecek bir sınıf koşmak() yöntem. Bu run () yöntemi, görevinizi uyguladığınız yerdir. Görevi kendi iş parçacığında başlatmak istediğinizde, bu sınıfın bir örneğini oluşturabilir ve görevini çağırabilirsiniz. başla() yöntem. Bu iş parçacığı yürütmesini başlatır ve tamamlanması için çalışır (veya bir istisna dışında sona erer).

Uzun süreli bir çalışmayı simüle etmenin bir yolu olarak sadece belirli bir süre için uyuyan basit bir Thread sınıfı.

kamu sınıfı MyThread, Thread private int sleepFor; genel MyThread (int sleepFor) this.sleepFor = sleepFor;  @Override public void run () System.out.printf ("[% s] iş parçacığı \ n", Thread.currentThread (). ToString ()); try Thread.sleep (this.sleepFor);  catch (InterruptedException ex)  System.out.printf ("\ n biten iş parçacığı" "%% s", Thread.currentThread (). toString ());  

Uyumayacak milisaniye sayısını vererek bu Thread sınıfının bir örneğini oluşturun.

MyThread çalışanı = yeni MyThread (sleepFor); 

Start () yöntemini çağırarak bu çalışan iş parçacığının yürütülmesini başlat. Bu yöntem, iş parçacığının sonlandırılmasını beklemeden hemen arayan kişiye kontrolü döndürür.

worker.start (); System.out.printf ("[% s] ana iş parçacığı \ n", Thread.currentThread (). ToString ()); 

Ve işte bu kodu çalıştırmanın sonucu. Çalışan iş parçacığı çalıştırılmadan önce ana iş parçacığı tanısının yazdırıldığını gösterir..

[Thread [main, 5, main]] ana başlık [Thread [Thread-0,5, main]] başlık başlangıcı [Thread [Thread-0,5, main]] başlık sonu 

İşçi iş parçacığı başladıktan sonra daha fazla ifade bulunmadığından, ana iş parçacığı çalışan iş parçacığının program bitmeden önce bitmesini bekler. Bu, çalışan iş parçacığının görevini tamamlamasını sağlar.

Yöntem 2: Çalıştırılabilir bir iş parçacığı örneği kullanma

Java da denilen bir arayüz sağlar Runnable Bir işçi sınıfı tarafından görevi yerine getirmek için uygulanabilir. koşmak() yöntem. Bu, uzatmanın aksine bir işçi sınıfı oluşturmanın alternatif bir yoludur. iplik sınıf (yukarıda açıklanmıştır).

İşte şimdi Threadn'ı uzatmak yerine Runnable uygulayan işçi sınıfının uygulaması.

genel sınıf MyThread2, Runnable // ile aynı komutunu uygular 

Thread sınıfını genişletmek yerine Runnable arabirimini uygulamanın avantajı, işçi sınıfının artık bir sınıf hiyerarşisi içerisindeki alana özgü bir sınıfı genişletebilmesidir..

Ne anlama geliyor?

Diyelim ki, örneğin bir Meyve Meyvelerin belirli genel özelliklerini uygulayan sınıf. Şimdi uygulamak istiyorsun Papaya meyve özelliklerinde uzmanlaşan sınıf. Bunu yaparak yapabilirsiniz Papaya sınıf genişletmek Meyve sınıf.

public class Fruit // fruit details burada] public sınıfı Papaya, Fruit // burada papaya'ya özgü davranışı geçersiz kılar 

Şimdi, Papaya'nın desteklemesi gereken, ayrı bir iş parçacığında gerçekleştirilebilecek zaman alıcı bir işiniz olduğunu varsayalım. Bu vaka, Papaya sınıfının Runnable uygulamasını yapması ve bu görevin gerçekleştirildiği run () yöntemini sağlaması ile ele alınabilir..

public class Papaya, Fruit uygulamasını çalıştırıyor // burada papaya'ya özgü davranışı geçersiz kılan davranışı geçersiz kılar.  

İşçi iş parçacığını başlatmak için, işçi sınıfının bir örneğini oluşturup onu oluşturma sırasında bir İş parçacığı örneğine devredersiniz. İş parçacığının start () yöntemi çağrıldığında, görev ayrı bir iş parçacığında yürütülür.

Papaya papaya = yeni Papaya (); // burada özellikleri belirle ve papaya yöntemlerini çağır. İplik ipliği = yeni İplik (papaya); thread.start (); 

Ve bu, bir iş parçacığı içinde yürütülen bir görevi uygulamak için bir Runnable'ın nasıl kullanılacağının kısa bir özetidir..

Yöntem 3: ExecutorService ile bir çalıştırılabilir yürütme

1.5 sürümünden başlayarak, Java bir ExecutorService bir program içinde iş parçacığı oluşturmak ve yönetmek için yeni bir paradigma olarak. İplik oluşumunu uzaklaştırarak iplik yürütme kavramını genelleştirir..

Bunun nedeni, görevlerinizi her bir görev için ayrı bir iş parçacığı kullanmak kadar kolay bir iş parçacığı havuzu içinde yürütebilmenizdir. Bu, programınızın çalışan görevlerinde kaç iş parçacığı kullanıldığını izlemesini ve yönetmesini sağlar.

Yürütülmeyi bekleyen 100 işçi göreviniz olduğunu varsayalım. Çalışan başına bir iş parçacığı başlatırsanız (yukarıda belirtildiği gibi), programınızın içinde programın başka bir yerinde darboğazlara neden olabilecek 100 iş parçacığınız olur. Bunun yerine, önceden ayrılmış 10 adet konuya sahip bir konu havuzu kullanıyorsanız, 100 göreviniz bu konu başlıkları tarafından birbiri ardına çalıştırılır, böylece programınız kaynaklar için aç kalmaz. Ayrıca, bu iş parçacığı havuzu iş parçacıkları, sizin için ek görevler gerçekleştirmek üzere takılmak üzere yapılandırılabilirler.

Bir ExecutorService bir kabul eder Runnable görev (yukarıda açıklanmıştır) ve görevi uygun bir zamanda çalıştırır. Gönder() Çalıştırılabilir görevi kabul eden yöntem, adında bir sınıf örneği döndürür. gelecek, Bu, arayan kişinin görevin durumunu izlemesini sağlar. Özellikle, almak() yöntemi, arayan kişinin görevin tamamlanmasını beklemesine izin verir (ve varsa dönüş kodunu sağlar).

Aşağıdaki örnekte, statik yöntemi kullanarak bir ExecutorService oluşturuyoruz newSingleThreadExecutor (), adından da anlaşılacağı gibi, görevleri yürütmek için tek bir iş parçacığı oluşturur. Bir görev çalışırken daha fazla görev gönderilirse, ExecutorService bu görevleri daha sonra yürütmek için sıraya koyar.

Burada kullandığımız Runnable uygulaması yukarıda açıklananla aynıdır..

ExecutorService esvc = Executors.newSingleThreadExecutor (); Çalıştırılabilir işçi = yeni MyThread2 (sleepFor); Gelecek gelecek = esvc.submit (işçi); System.out.printf ("[% s] ana iş parçacığı \ n", Thread.currentThread (). ToString ()); future.get (); esvc.shutdown (); 

Başka bir görev için artık gerekmediğinde bir ExecutorService'in düzgün bir şekilde kapatılması gerektiğini unutmayın..

Yöntem 4: ExecutorService ile birlikte kullanılan bir Callable

1.5 sürümünden başlayarak, Java adında yeni bir arayüz tanıtıldı istenebilen. Yürütme yönteminin (çağırılan) farkı ile daha eski Runnable arabirimine benzer telefon etmek() yerine koşmak()) bir değer döndürebilir. Buna ek olarak, aynı zamanda bir İstisna atılabilir.

Bir ExecutorService ayrıca olarak uygulanan görevleri kabul edebilir istenebilen ve bir verir gelecek tamamlandığında metod tarafından döndürülen değer ile.

İşte bir örnek Mango genişleten sınıf Meyve Daha önce tanımlanmış olan sınıf istenebilen arayüz. İçinde pahalı ve zaman alıcı bir görev gerçekleştirilir. telefon etmek() yöntem.

genel sınıf Mango, Fruit ürününü kullanabiliyor Callable public Integer call () // burada pahalı olan hesaplamalar yeni Integer (0);  

Ve işte sınıfın bir örneğini ExecutorService’e gönderme kodu. Aşağıdaki kod da görevin tamamlanmasını ve dönüş değerini yazdırmasını bekler..

ExecutorService esvc = Executors.newSingleThreadExecutor (); MyCallable çalışanı = yeni MyCallable (sleepFor); Gelecek gelecek = esvc.submit (işçi); System.out.printf ("[% s] ana iş parçacığı \ n", Thread.currentThread (). ToString ()); System.out.println ("Görev geri döndü:" + future.get ()); esvc.shutdown (); 

Ne tercih edersin?

Bu yazıda, Java'da çok iş parçacıklı kod yazmak için birkaç yöntem öğrendik. Bunlar şunları içerir:

1. Genişletme iplik sınıf en temel olanıdır ve Java 1.0'dan edinilmiştir..
2. Bir sınıf hiyerarşisinde başka bir sınıfı genişletmesi gereken bir sınıfınız varsa, bunu uygulayabilirsiniz. Runnable arayüzey.
3. Konu oluşturmak için daha modern bir tesis ExecutorService Runnable örneğini çalıştırılacak bir görev olarak kabul edebilir. Bu yöntemin avantajı, görev yürütme için bir iş parçacığı havuzu kullanabilmenizdir. Bir iş parçacığı havuzu, iş parçacıklarını yeniden kullanarak kaynağın korunmasına yardımcı olur.
4. Son olarak, uygulamayı uygulayarak da bir görev oluşturabilirsiniz. istenebilen arayüz ve görevi bir ExecutorService'e gönderme.

Bir sonraki projenizde bu seçeneklerden hangisini kullanacağınızı düşünüyorsunuz? Aşağıdaki yorumlarda bize bildirin.