Çoklu iş parçacığı ve Senkronizasyon, Java programlamanın tipik bölümü olarak kabul edilir. Oyun geliştirme şirketlerinde çoğunlukla multithreading ile ilgili röportaj soruları sorulmaktadır. Sık sorulan Java çoklu iş parçacığı ve eşzamanlılık röportaj sorularının bir listesi aşağıda verilmiştir.

Çok İş Parçalı Mülakat Soruları

1) Çoklu iş parçacığı nedir?

Çoklu iş parçacığı, birden fazla iş parçacığının aynı anda yürütülmesi işlemidir. Çoklu görevi elde etmek için çoklu iş parçacığı kullanılır. Daha az bellek tüketir ve hızlı ve verimli performans sağlar. Başlıca avantajları şunlardır:

• Konular aynı adres alanını paylaşır.
• İplik hafiftir.
• Süreçler arasındaki iletişimin maliyeti düşüktür.

2) Konu nedir?

Bir iş parçacığı hafif bir alt işlemdir. Her iş parçacığı farklı bir yığın çerçevesinde çalıştığı için bu ayrı bir yürütme yoludur. Bir süreç birden fazla iş parçacığı içerebilir. İş parçacıkları süreç kaynaklarını paylaşır ancak yine de bağımsız olarak yürütülürler.

3) Süreç ve iş parçacığı arasında ayrım yapıyor musunuz?

İşlem ve iş parçacığı arasında aşağıdaki farklar vardır.

• Yürütmedeki bir Programa süreç adı verilirken; Bir iş parçacığı sürecin bir alt kümesidir
• Süreçler bağımsızdır, oysa iş parçacıkları sürecin alt kümesidir.
• İşlemler bellekte farklı adres alanlarına sahipken, iş parçacıkları paylaşılan bir adres alanı içerir.
• Süreçlerle karşılaştırıldığında iş parçacıkları arasında bağlam değişimi daha hızlıdır.
• İşlemler arası iletişim, iş parçacıkları arası iletişime göre daha yavaş ve pahalıdır.
• Ana süreçteki herhangi bir değişiklik alt süreci etkilemezken ana iş parçacığında yapılan değişiklikler alt iş parçacığını etkileyebilir.

4) İş parçacıkları arası iletişimden ne anlıyorsunuz?

• Senkronize iş parçacıkları arasındaki iletişim sürecine iş parçacıkları arası iletişim denir.
• İş parçacığı arası iletişim, Java'da iş parçacığı sorgulamasını önlemek için kullanılır.
• İş parçacığı kritik bölümünde çalışırken duraklatılır ve başka bir iş parçacığının yürütülmek üzere aynı kritik bölüme girmesine (veya kilitlenmesine) izin verilir.
• wait(), notify() ve notifyAll() yöntemleriyle elde edilebilir.

5) Java'da wait() yönteminin amacı nedir?

wait() yöntemi Java'daki Object sınıfı tarafından sağlanır. Bu yöntem Java'da iş parçacıkları arası iletişim için kullanılır. Java.lang.Object.wait() geçerli iş parçacığını duraklatmak ve başka bir iş parçacığının notify() veya notifyAll() yöntemini çağırmamasını beklemek için kullanılır. Söz dizimi aşağıda verilmiştir.

genel son geçersiz bekleme()

6) Senkronize bloktan wait() yönteminin neden çağrılması gerekiyor?

Bekleme yöntemini çağırmalıyız, aksi takdirde fırlatır java.lang.IllegalMonitorStateException istisna. Ayrıca notify() ve notifyAll() ile iş parçacıkları arası iletişim için wait() yöntemine ihtiyacımız var. Bu nedenle doğru ve doğru iletişim için senkronize blokta bulunması gerekir.

7) Çoklu iş parçacığının avantajları nelerdir?

Çok iş parçacıklı programlamanın aşağıdaki avantajları vardır:

• Çoklu iş parçacığı, bir uygulamanın/programın, bazı arka plan görevleriyle zaten çalışıyor olsa bile, giriş için her zaman reaktif olmasını sağlar
• Çoklu iş parçacığı, iş parçacıkları bağımsız olarak yürütüldüğü için görevlerin daha hızlı yürütülmesine olanak tanır.
• Çoklu iş parçacığı, iş parçacıkları ortak bellek kaynaklarını paylaştığından önbelleğin daha iyi kullanılmasını sağlar.
• Çoklu iş parçacığı, bir sunucunun aynı anda birden fazla iş parçacığını çalıştırabilmesi nedeniyle gerekli sunucu sayısını azaltır.

8) Bir Thread'in yaşam döngüsündeki durumlar nelerdir?

Bir iş parçacığı ömrü boyunca aşağıdaki durumlardan birine sahip olabilir:

Yeni:Bu durumda, yeni bir operatör kullanılarak bir Thread sınıfı nesnesi oluşturulur, ancak iş parçacığı canlı değildir. Start() yöntemini çağırıncaya kadar iş parçacığı başlamaz.Çalıştırılabilir:Bu durumda, iş parçacığı start() yöntemi çağrıldıktan sonra çalışmaya hazırdır. Ancak iş parçacığı henüz iş parçacığı planlayıcısı tarafından seçilmedi.Koşma:Bu durumda, iş parçacığı zamanlayıcı iş parçacığını hazır durumdan alır ve iş parçacığı çalışmaktadır.Bekleniyor/Engellendi:Bu durumda, bir iş parçacığı çalışmıyor ancak hala hayatta veya diğer iş parçacığının bitmesini bekliyor.Öldü/Sonlandırıldı:run() yönteminden çıkıldığında bir iş parçacığı sonlandırılmış veya ölü durumdadır.

9) Önleyici planlama ile zaman dilimleme arasındaki fark nedir?

Önleyici planlamada, en yüksek öncelikli görev, bekleme veya ölü duruma girene veya daha yüksek öncelikli bir görev ortaya çıkana kadar yürütülür. Zaman dilimlemede, bir görev önceden tanımlanmış bir zaman diliminde yürütülür ve ardından hazır görevler havuzuna yeniden girer. Zamanlayıcı daha sonra önceliğe ve diğer faktörlere bağlı olarak bir sonraki görevin hangi görevin yürütülmesi gerektiğini belirler.

10) Bağlam değiştirme nedir?

Bağlam değiştirmede işlemin (veya iş parçacığının) durumu, geri yüklenebilmesi ve yürütmenin daha sonra aynı noktadan devam ettirilebilmesi için saklanır. Bağlam değiştirme, birden fazla işlemin aynı CPU'yu paylaşmasına olanak tanır.

11) Bir Konu oluşturmak için Thread sınıfı ile Runnable arayüzü arasında ayrım yapmak mı istiyorsunuz?

Konu iki şekilde oluşturulabilir.

• Thread sınıfını genişleterek
• Runnable arayüzünü uygulayarak

Ancak her iki yol arasındaki temel farklar aşağıda verilmiştir:

• Java, Runnable arayüzünü uygularken birden fazla kalıtıma izin vermediğinden, Thread sınıfını genişleterek başka bir sınıfı genişletemeyiz; diğer temel sınıfı da genişletebiliriz (gerekirse).
• Thread sınıfını genişleterek, her iş parçacığı benzersiz nesneyi oluşturur ve Runnable arabirimini uygularken onunla ilişkilendirilir; birden fazla iş parçacığı aynı nesneyi paylaşır
• Thread sınıfı getPriority(), isAlive ve çok daha fazlası gibi çeşitli dahili yöntemler sağlarken Runnable arayüzü tek bir yöntem sağlar, yani run().

12) join() yöntemi ne işe yarar?

join() yöntemi bir iş parçacığının ölmesini bekler. Başka bir deyişle, o anda çalışan iş parçacıklarının, katıldığı iş parçacığı görevini tamamlayana kadar yürütmeyi durdurmasına neden olur. join yöntemi Thread sınıfında aşağıdaki şekillerde aşırı yüklenmiştir.

• public void join() InterruptedException'ı atar
• public void join (uzun milisaniye) InterruptedException'ı atar

13) Sleep() yönteminin amacını ve çalışmasını açıklayınız.

Java'daki uyku () yöntemi, bir iş parçacığını belirli bir süre boyunca engellemek için kullanılır; bu, bir iş parçacığının yürütülmesini belirli bir süre duraklattığı anlamına gelir. Bunu yapmanın iki yöntemi vardır.

Sözdizimi:

java'da istisna işleme atma

• genel statik geçersiz uyku (uzun milisaniye) InterruptedException'ı atar
• genel statik geçersiz uyku (uzun milisaniye, int nanos) InterruptedException'ı atar

Sleep() yönteminin çalışması

Sleep() yöntemini çağırdığımızda, mevcut iş parçacığının yürütülmesini verilen süre boyunca duraklatır ve (varsa) başka bir iş parçacığına öncelik verir. Üstelik, bekleme süresi tamamlandığında, önceki iş parçacığı bekleme durumundan çalıştırılabilir duruma geçer ve çalışır duruma gelir ve yürütme tamamlanıncaya kadar tüm süreç böyle devam eder.

14) wait() ve uyku() yöntemi arasındaki fark nedir?

15) Bir konuyu iki kez başlatmak mümkün mü?

Hayır, iş parçacığı başlatılıp yürütüldüğünde Ölü durumuna geçtiği için iş parçacığını yeniden başlatamayız. Bu nedenle, bir iş parçacığını iki kez başlatmayı denersek, runtimeException 'java.lang.IllegalThreadStateException' sonucunu verecektir. Aşağıdaki örneği düşünün.

 public class Multithread1 extends Thread { public void run() { try { System.out.println('thread is executing now........'); } catch(Exception e) { } } public static void main (String[] args) { Multithread1 m1= new Multithread1(); m1.start(); m1.start(); } } 

Çıktı

 thread is executing now........ Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.start(Thread.java:708) at Multithread1.main(Multithread1.java:13) 

16) start() yerine run() yöntemini çağırabilir miyiz?

Evet, run() yöntemini doğrudan çağırmak geçerlidir, ancak bir iş parçacığı olarak çalışmaz, bunun yerine normal bir nesne olarak çalışır. Konular arasında bağlam değişimi yapılmayacaktır. start() yöntemini çağırdığımızda, run() yöntemini dahili olarak çağırır; bu, bir iş parçacığı için yeni bir yığın oluştururken run() yöntemini doğrudan çağırmak yeni bir yığın oluşturmaz.

17) Daemon iş parçacıkları ne olacak?

Daemon iş parçacıkları, kullanıcı iş parçacıklarına arka plan desteği ve hizmetleri sağlayan düşük öncelikli iş parçacıklarıdır. Program yalnızca daemon iş parçacığında kalırsa ve diğer tüm kullanıcı iş parçacıkları sonlandırılırsa/ölürse Daemon iş parçacığı JVM tarafından otomatik olarak sonlandırılır. Thread sınıfında daemon thread için iki yöntem mevcuttur:

public void setDaemon(boole durumu):İş parçacığı daemon iş parçacığını veya bir kullanıcı iş parçacığını işaretlemek için kullanılır.genel boolean isDaemon():İş parçacığının daemon olup olmadığını kontrol eder.

18)Eğer iş parçacığı başlatılırsa, kullanıcı iş parçacığını daemon iş parçacığı olarak yapabilir miyiz?

Hayır, bunu yaparsanız IllegalThreadStateException hatasına neden olur. Bu nedenle, iş parçacığını başlatmadan önce yalnızca bir daemon iş parçacığı oluşturabiliriz.

 class Testdaemon1 extends Thread{ public void run(){ System.out.println('Running thread is daemon...'); } public static void main (String[] args) { Testdaemon1 td= new Testdaemon1(); td.start(); setDaemon(true);// It will throw the exception: td. } } 

Çıktı

 Running thread is daemon... Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.setDaemon(Thread.java:1359) at Testdaemon1.main(Testdaemon1.java:8) 

19)Kapatma kancası nedir?

Kapatma kancası, JVM kapatılmadan önce dolaylı olarak çağrılan bir iş parçacığıdır. Böylece JVM normal veya aniden kapandığında kaynağı temizlemek veya durumu kaydetmek için bunu kullanabiliriz. Aşağıdaki yöntemi kullanarak kapatma kancasını ekleyebiliriz:

 public�void�addShutdownHook(Thread�hook){}�� Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); 

Kapatma kancalarıyla ilgili bazı önemli noktalar şunlardır:

• Kapatma kancaları başlatıldı ancak yalnızca JVM kapatıldığında başlatılabilir.
• Kapatma kancaları sonlandırıcıdan () daha güvenilirdir çünkü kapatma kancalarının çalışmama olasılığı çok azdır.
• Kapatma kancası, Runtime sınıfının halt(int) yöntemi çağrılarak durdurulabilir.

20) Bir konuyu ne zaman kesmeliyiz?

Bir iş parçacığının uyku veya bekleme durumunu kırmak istediğimizde, iş parçacığını kesmeliyiz. InterruptedException'ı atarak, Interrupted()'ı çağırarak bir iş parçacığını kesebiliriz.

MySQL'e eşit değil

21) Senkronizasyon nedir?

Senkronizasyon, birden fazla iş parçacığının herhangi bir paylaşılan kaynağa erişimini kontrol etme yeteneğidir. Şunlar kullanılır:

1. İplik girişimini önlemek için.
2. Tutarlılık sorununu önlemek için.

Birden fazla iş parçacığı aynı görevi yapmaya çalıştığında hatalı sonuç olasılığı vardır, dolayısıyla bu sorunu ortadan kaldırmak için Java, aynı anda yalnızca bir iş parçacığının yürütülmesine izin veren senkronizasyon işlemini kullanır. Senkronizasyon üç şekilde gerçekleştirilebilir:

• senkronize yöntemle
• senkronize blokla
• statik senkronizasyonla

Senkronize blok için sözdizimi

 synchronized(object reference expression) { //code block } 

22) Senkronize bloğun amacı nedir?

Senkronize blok, yöntemin herhangi bir belirli kaynağı üzerinde senkronizasyon gerçekleştirmek için kullanılabilir. Belirli bir kaynak üzerinde aynı anda yalnızca bir iş parçacığı yürütülebilir ve senkronize bloğa girmeye çalışan diğer tüm iş parçacıkları engellenir.

• Senkronize blok, herhangi bir paylaşılan kaynak için bir nesneyi kilitlemek için kullanılır.
• Senkronize bloğun kapsamı, uygulandığı blokla sınırlıdır. Kapsamı bir yöntemden daha küçüktür.

23)Java nesnesi belirli bir iş parçacığının özel kullanımı için kilitlenebilir mi?

Evet. Bir nesneyi 'senkronize' bir bloğa yerleştirerek kilitleyebilirsiniz. Kilitli nesneye, onu açıkça talep eden iş parçacığı dışındaki hiçbir iş parçacığı tarafından erişilemez.

24) Statik senkronizasyon nedir?

Herhangi bir statik metodu senkronize yaparsanız kilit nesnede değil sınıfta olacaktır. Bir yöntemden önce synchronized anahtar sözcüğünü kullanırsak nesneyi kilitler (bir iş parçacığı aynı anda bir nesneye erişebilir), ancak statik senkronize kullanırsak bir sınıfı kilitler (bir iş parçacığı aynı anda bir sınıfa erişebilir). Daha fazla detay.

25)notify() ve notifyAll() arasındaki fark nedir?

Notify(), bekleyen bir iş parçacığının engellemesini kaldırmak için kullanılırken notifyAll() yöntemi, bekleme durumundaki tüm iş parçacıklarının engellemesini kaldırmak için kullanılır.

26) Kilitlenme nedir?

Kilitlenme, her iş parçacığının başka bir bekleyen iş parçacığı tarafından tutulan bir kaynağı beklediği bir durumdur. Bu durumda, ne iş parçacığının hiçbiri yürütülür ne de yürütülme şansı olur. Bunun yerine, tüm iş parçacıkları arasında evrensel bir bekleme durumu mevcuttur. Kilitlenme, çalışma zamanında kodumuzu bozabilecek çok karmaşık bir durumdur.

27) Kilitlenme durumu nasıl tespit edilir? Nasıl önlenebilir?

Deadlock durumunu cmd'de çalıştırıp Thread Dump'ı toplayarak tespit edebiliriz ve kodda herhangi bir deadlock varsa cmd'de bir mesaj görünecektir.

Java'da kilitlenme durumunu önlemenin yolları:

Yuvalanmış kilitten kaçının:İç içe kilit, kilitlenmenin yaygın nedenidir, çünkü çeşitli iş parçacıklarına kilitler sağladığımızda kilitlenme meydana gelir, dolayısıyla belirli bir zamanda yalnızca bir iş parçacığına bir kilit vermemiz gerekir.Gereksiz kilitlerden kaçının:Gerekli olmayan kilitlerden kaçınmalıyız.İş parçacığı birleştirmeyi kullanma:İş parçacığının birleştirilmesi, başka bir iş parçacığının yürütülmesini tamamlamayana kadar bir iş parçacığını beklemeye yardımcı olur, böylece birleştirme yöntemini maksimum düzeyde kullanarak kilitlenmeyi önleyebiliriz.

28) Java'da Konu Zamanlayıcı nedir?

Java'da iş parçacıklarını oluşturduğumuzda, bunlar JVM'nin bir parçası olan İş Parçacığı Zamanlayıcısı yardımıyla denetlenir. İş parçacığı planlayıcısı yalnızca hangi iş parçacığının yürütülmesi gerektiğine karar vermekten sorumludur. İş parçacığı zamanlayıcı, iş parçacıklarını zamanlamak için iki mekanizma kullanır: Önleyici ve Zaman Dilimleme.

• İş parçacığının önceliğini seçer.
• Bir iş parçacığının bekleme süresini belirler
• İpliğin doğasını kontrol eder

29) Çok iş parçacıklı programlamada her iş parçacığının kendi yığını var mı?

Evet, çok iş parçacıklı programlamada, her iş parçacığı birbirinden bağımsız olduğundan, her iş parçacığı bellekte kendi veya ayrı yığın alanını korur.

100kmh ila mil/saat

30) Bir ipliğin güvenliği nasıl sağlanır?

Bir yöntem veya sınıf nesnesi, herhangi bir yarış koşulu olmadan aynı anda birden fazla iş parçacığı tarafından kullanılabiliyorsa, o zaman sınıf iş parçacığı açısından güvenlidir. İş parçacığı güvenliği, bir programın çok iş parçacıklı programlamada kullanımını güvenli hale getirmek için kullanılır. Aşağıdaki yollarla elde edilebilir:

• Senkronizasyon
• Uçucu anahtar kelime kullanma
• Kilit tabanlı bir mekanizma kullanma
• Atomik sarmalayıcı sınıflarının kullanımı

31) Yarış durumu nedir?

Yarış durumu, çok iş parçacıklı programlamada, çeşitli iş parçacıklarının aynı anda paylaşılan bir kaynağa erişerek eşzamanlı olarak yürütülmesi durumunda ortaya çıkan bir sorundur. Senkronizasyonun doğru kullanımı Yarış durumunu önleyebilir.

32) Java'daki uçucu anahtar kelime nedir?

Uçucu anahtar kelime, iş parçacığı güvenliğini sağlamak için çok iş parçacıklı programlamada kullanılır, çünkü bir uçucu değişkendeki değişiklik diğer tüm iş parçacıkları tarafından görülebilir, böylece bir değişken aynı anda bir iş parçacığı tarafından kullanılabilir.

33) İş parçacığı havuzundan ne anlıyorsunuz?

• Java İş parçacığı havuzu, görevin tahsis edilmesini bekleyen bir grup çalışan iş parçacığını temsil eder.
• İş parçacığı havuzundaki iş parçacıkları, havuzdan bir iş parçacığını çeken ve ona bir iş atayan servis sağlayıcı tarafından denetlenir.
• Verilen görev tamamlandıktan sonra iş parçacığı tekrar iş parçacığı havuzuna geldi.
• İş parçacığı havuzunun boyutu, yürütme için yedekte tutulan toplam iş parçacığı sayısına bağlıdır.

İş parçacığı havuzunun avantajları şunlardır:

• Bir iş parçacığı havuzu kullanılarak performans artırılabilir.
• Bir iş parçacığı havuzu kullanılarak daha iyi sistem kararlılığı elde edilebilir.

Eşzamanlı Mülakat Soruları

34) Eşzamanlılık API'sinin ana bileşenleri nelerdir?

Concurrency API, java.util.Concurrent paketinin sınıfı ve arayüzleri kullanılarak geliştirilebilir. Java.util.Concurrent paketinde aşağıdaki sınıflar ve arayüzler bulunmaktadır.

• İcracı
• FarkJoinHavuzu
• YöneticiHizmet
• ZamanlanmışYürütücüHizmeti
• Gelecek
• Zaman Birimi(Enum)
• Geri SayımMandal
• DöngüselBariyer
• Semafor
• Konu Fabrikası
• Engelleme Sırası
• Gecikme Kuyruğu
• Kilitler
• Fazer

35) Java'daki Concurrency API'sindeki Executor arayüzü nedir?

Java.util.concurrent paketi tarafından sağlanan Yürütücü Arayüzü, yeni görevi yürütmek için kullanılan basit arayüzdür. Executor arayüzünün executive() yöntemi, verilen bazı komutları yürütmek için kullanılır. Execute() metodunun sözdizimi aşağıda verilmiştir.

geçersiz yürütme (Çalıştırılabilir komut)

Aşağıdaki örneği düşünün:

 import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { Executor e = Executors.newCachedThreadPool(); e.execute(new Thread()); ThreadPoolExecutor pool = (ThreadPoolExecutor)e; pool.shutdown(); } static class Thread implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 5); System.out.println('Running Thread!'); TimeUnit.SECONDS.sleep(duration); System.out.println('Thread Completed'); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Çıktı

 Running Thread! Thread Completed 

36) BlockingQueue nedir?

Java.util.concurrent.BlockingQueue, yeni bir değer eklemeden önce alan kullanılabilirliğini beklemek veya ondan bir öğe almadan önce kuyruğun boş kalmasını beklemek gibi işlemleri destekleyen Queue'nun alt arayüzüdür. Aşağıdaki örneği düşünün.

 import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { BlockingQueue queue = new ArrayBlockingQueue(10); Insert i = new Insert(queue); Retrieve r = new Retrieve(queue); new Thread(i).start(); new Thread(r).start(); Thread.sleep(2000); } static class Insert implements Runnable { private BlockingQueue queue; public Insert(BlockingQueue queue) { this.queue = queue; } @Override public void run() { Random random = new Random(); try { int result = random.nextInt(200); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(10); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(50); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); } catch (InterruptedException e) { e.printStackTrace(); } } } static class Retrieve implements Runnable { private BlockingQueue queue; public Retrieve(BlockingQueue queue) { this.queue = queue; } @Override public void run() { try { System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } } } } 

Çıktı

 Added: 96 Removed: 96 Added: 8 Removed: 8 Added: 5 Removed: 5 

37) Üretici-tüketici problemi BlockingQueue kullanılarak nasıl uygulanır?

Üretici-tüketici sorunu BlockingQueue kullanılarak aşağıdaki şekilde çözülebilir.

wumpus dünyası

 import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.logging.Level; import java.util.logging.Logger; public class ProducerConsumerProblem { public static void main(String args[]){ //Creating shared object BlockingQueue sharedQueue = new LinkedBlockingQueue(); //Creating Producer and Consumer Thread Thread prod = new Thread(new Producer(sharedQueue)); Thread cons = new Thread(new Consumer(sharedQueue)); //Starting producer and Consumer thread prod.start(); cons.start(); } } //Producer Class in java class Producer implements Runnable { private final BlockingQueue sharedQueue; public Producer(BlockingQueue sharedQueue) { this.sharedQueue = sharedQueue; } @Override public void run() { for(int i=0; i<10; i++){ try { system.out.println('produced: ' + i); sharedqueue.put(i); } catch (interruptedexception ex) logger.getlogger(producer.class.getname()).log(level.severe, null, ex); consumer class in java implements runnable{ private final blockingqueue sharedqueue; public (blockingqueue sharedqueue) this.sharedqueue="sharedQueue;" @override void run() while(true){ system.out.println('consumed: '+ sharedqueue.take()); logger.getlogger(consumer.class.getname()).log(level.severe, < pre> <p> <strong>Output</strong> </p> <pre> Produced: 0 Produced: 1 Produced: 2 Produced: 3 Produced: 4 Produced: 5 Produced: 6 Produced: 7 Produced: 8 Produced: 9 Consumed: 0 Consumed: 1 Consumed: 2 Consumed: 3 Consumed: 4 Consumed: 5 Consumed: 6 Consumed: 7 Consumed: 8 Consumed: 9 </pre> <hr> <h3>38) What is the difference between Java Callable interface and Runnable interface?</h3> <p>The Callable interface and Runnable interface both are used by the classes which wanted to execute with multiple threads. However, there are two main differences between the both : </p> <ul> <li>A Callable interface can return a result, whereas the Runnable interface cannot return any result.</li> <li>A Callable interface can throw a checked exception, whereas the Runnable interface cannot throw checked exception. </li> <li>A Callable interface cannot be used before the Java 5 whereas the Runnable interface can be used.</li> </ul> <hr> <h3>39) What is the Atomic action in Concurrency in Java?</h3> <ul> <li>The Atomic action is the operation which can be performed in a single unit of a task without any interference of the other operations.</li> <li>The Atomic action cannot be stopped in between the task. Once started it fill stop after the completion of the task only. </li> <li>An increment operation such as a++ does not allow an atomic action.</li> <li>All reads and writes operation for the primitive variable (except long and double) are the atomic operation.</li> <li>All reads and writes operation for the volatile variable (including long and double) are the atomic operation.</li> <li>The Atomic methods are available in java.util.Concurrent package. </li> </ul> <hr> <h3>40) What is lock interface in Concurrency API in Java?</h3> <p>The java.util.concurrent.locks.Lock interface is used as the synchronization mechanism. It works similar to the synchronized block. There are a few differences between the lock and synchronized block that are given below.</p> <ul> <li>Lock interface provides the guarantee of sequence in which the waiting thread will be given the access, whereas the synchronized block doesn&apos;t guarantee it.</li> <li>Lock interface provides the option of timeout if the lock is not granted whereas the synchronized block doesn&apos;t provide that.</li> <li>The methods of Lock interface, i.e., Lock() and Unlock() can be called in different methods whereas single synchronized block must be fully contained in a single method.</li> </ul> <hr> <h3>41) Explain the ExecutorService Interface.</h3> <p>The ExecutorService Interface is the subinterface of Executor interface and adds the features to manage the lifecycle. Consider the following example.</p> <pre> import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println(&apos;Shutdown executor&apos;); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println(&apos;tasks interrupted&apos;); } finally { if (!e.isTerminated()) { System.err.println(&apos;cancel non-finished tasks&apos;); } e.shutdownNow(); System.out.println(&apos;shutdown finished&apos;); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println(&apos;Running Task!&apos;); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } </pre> <p> <strong>Output</strong> </p> <pre> Shutdown executor shutdown finished </pre> <hr> <h3>42) What is the difference between Synchronous programming and Asynchronous programming regarding a thread?</h3> <p> <strong>Synchronous programming: </strong> In Synchronous programming model, a thread is assigned to complete a task and hence thread started working on it, and it is only available for other tasks once it will end the assigned task.</p> <p> <strong>Asynchronous Programming: </strong> In Asynchronous programming, one job can be completed by multiple threads and hence it provides maximum usability of the various threads.</p> <hr> <h3>43) What do you understand by Callable and Future in Java?</h3> <p> <strong>Java Callable interface: </strong> In Java5 callable interface was provided by the package java.util.concurrent. It is similar to the Runnable interface but it can return a result, and it can throw an Exception. It also provides a run() method for execution of a thread. Java Callable can return any object as it uses Generic.</p> <p> <strong>Syntax:</strong> </p> <p>public interface Callable</p> <p> <strong>Java Future interface:</strong> Java Future interface gives the result of a concurrent process. The Callable interface returns the object of java.util.concurrent.Future.</p> <p>Java Future provides following methods for implementation.</p> <ul> <tr><td>cancel(boolean&#xFFFD;mayInterruptIfRunning):</td> It is used to cancel the execution of the assigned task. </tr><tr><td>get():</td> It waits for the time if execution not completed and then retrieved the result. </tr><tr><td>isCancelled():</td> It returns the Boolean value as it returns true if the task was canceled before the completion. </tr><tr><td>isDone():</td> It returns true if the job is completed successfully else returns false. </tr></ul> <hr> <h3>44. What is the difference between ScheduledExecutorService and ExecutorService interface?</h3> <p>ExecutorServcie and ScheduledExecutorService both are the interfaces of java.util.Concurrent package but scheduledExecutorService provides some additional methods to execute the Runnable and Callable tasks with the delay or every fixed time period.</p> <h3>45) Define FutureTask class in Java? </h3> <p>Java FutureTask class provides a base implementation of the Future interface. The result can only be obtained if the execution of one task is completed, and if the computation is not achieved then get method will be blocked. If the execution is completed, then it cannot be re-started and can&apos;t be canceled.</p> <p> <strong>Syntax</strong> </p> <p>public class FutureTask extends Object implements RunnableFuture</p> <hr></10;>

38) Java Callable arayüzü ile Runnable arayüzü arasındaki fark nedir?

Callable arayüzü ve Runnable arayüzünün her ikisi de, birden fazla iş parçacığı ile yürütmek isteyen sınıflar tarafından kullanılır. Ancak her ikisi arasında iki temel fark vardır:

• Callable arayüzü bir sonuç döndürebilirken, Runnable arayüzü herhangi bir sonuç döndüremez.
• Callable arayüzü kontrol edilen bir istisna atabilirken, Runnable arayüzü kontrol edilen istisnayı atamaz.
• Java 5'ten önce Callable arayüzü kullanılamazken Runnable arayüzü kullanılabilir.

39) Java'da Eşzamanlılıktaki Atomik eylem nedir?

• Atomik eylem, bir görevin tek bir biriminde, diğer işlemlere herhangi bir müdahale olmaksızın gerçekleştirilebilen işlemdir.
• Atomik eylem görev arasında durdurulamaz. Bir kez başlatıldığında, yalnızca görevin tamamlanmasından sonra durur.
• A++ gibi bir artırma işlemi atomik bir eyleme izin vermez.
• İlkel değişkene yönelik tüm okuma ve yazma işlemleri (uzun ve çift hariç) atomik işlemdir.
• Uçucu değişkene yönelik tüm okuma ve yazma işlemleri (uzun ve çift dahil) atomik işlemdir.
• Atomik yöntemler Java.util.Concurrent paketinde mevcuttur.

40) Java'daki Eşzamanlılık API'sindeki kilit arayüzü nedir?

Senkronizasyon mekanizması olarak java.util.concurrent.locks.Lock arayüzü kullanılır. Senkronize bloğa benzer şekilde çalışır. Kilit ile senkronize blok arasında aşağıda verilen birkaç fark vardır.

• Kilit arayüzü, bekleyen iş parçacığına erişim verilecek sıranın garantisini sağlarken senkronize blok bunu garanti etmez.
• Kilit arayüzü, kilidin verilmemesi durumunda zaman aşımı seçeneğini sağlarken senkronize blok bunu sağlamaz.
• Lock arayüzünün yöntemleri, yani Lock() ve unlock() farklı yöntemlerde çağrılabilirken, tek senkronize bloğun tamamen tek bir yöntemde yer alması gerekir.

41) ExecutorService Arayüzünü açıklayınız.

ExecutorService Arayüzü, Executor arayüzünün alt arayüzüdür ve yaşam döngüsünü yönetmek için özellikler ekler. Aşağıdaki örneği düşünün.

 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println('Shutdown executor'); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println('tasks interrupted'); } finally { if (!e.isTerminated()) { System.err.println('cancel non-finished tasks'); } e.shutdownNow(); System.out.println('shutdown finished'); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println('Running Task!'); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Çıktı

 Shutdown executor shutdown finished 

42) Bir iş parçacığına ilişkin Senkron programlama ile Asenkron programlama arasındaki fark nedir?

Senkron programlama: Senkron programlama modelinde, bir görevi tamamlamak için bir iş parçacığı atanır ve dolayısıyla iş parçacığı bu iş üzerinde çalışmaya başlar ve yalnızca atanan görevi sonlandırdıktan sonra diğer görevler için kullanılabilir.

Asenkron Programlama: Asenkron programlamada, bir iş birden fazla iş parçacığı tarafından tamamlanabilir ve dolayısıyla çeşitli iş parçacıklarının maksimum kullanılabilirliğini sağlar.

43) Java'da Callable ve Future'dan ne anlıyorsunuz?

Java Çağrılabilir arayüz: Java5'te çağrılabilir arayüz Java.util.concurrent paketi tarafından sağlandı. Runnable arayüzüne benzer ancak bir sonuç döndürebilir ve bir İstisna oluşturabilir. Ayrıca bir iş parçacığının yürütülmesi için bir run() yöntemi sağlar. Java Callable, Generic'i kullandığı için herhangi bir nesneyi döndürebilir.

Sözdizimi:

genel arayüz Çağrılabilir

Java Gelecek arayüzü: Java Future arayüzü eşzamanlı bir sürecin sonucunu verir. Callable arayüzü java.util.concurrent.Future nesnesini döndürür.

Java Future, uygulama için aşağıdaki yöntemleri sağlar.

cancel(boolean�mayInterruptIfRunning):Atanan görevin yürütülmesini iptal etmek için kullanılır.elde etmek():Yürütme tamamlanmadıysa süreyi bekler ve ardından sonucu alır.iptal edildi():Görev tamamlanmadan önce iptal edilmişse true değerini döndürdüğü için Boolean değerini döndürür.bitti():Eğer iş başarıyla tamamlanırsa true değeri döner, aksi halde false değeri döner.

44. ScheduledExecutorService ve ExecutorService arayüzü arasındaki fark nedir?

ExecutorServcie ve ScheduledExecutorService, java.util.Concurrent paketinin arayüzleridir ancak ScheduledExecutorService, Runnable ve Callable görevlerini gecikmeyle veya her sabit zaman diliminde yürütmek için bazı ek yöntemler sağlar.

45) Java'da FutureTask sınıfını tanımlayın?

Java FutureTask sınıfı, Future arayüzünün temel uygulamasını sağlar. Sonuç yalnızca bir görevin yürütülmesi tamamlandığında elde edilebilir ve hesaplama gerçekleştirilemezse get yöntemi engellenir. Yürütme tamamlanmışsa yeniden başlatılamaz ve iptal edilemez.

Sözdizimi

genel sınıf FutureTask Object'i genişletiyor RunnableFuture'ı uyguluyor