logo

TechCodeview

Java マルチスレッドと同時実行に関する面接の質問

マルチスレッドと同期は、Java プログラミングの典型的な章とみなされます。ゲーム開発会社では、面接でよく聞かれるのはマルチスレッド関連の質問です。 Java マルチスレッドおよび同時実行に関する面接でよくある質問のリストを以下に示します。

マルチスレッドに関する面接の質問

1) マルチスレッドとは何ですか?

マルチスレッドとは、複数のスレッドを同時に実行するプロセスです。マルチタスクを実現するためにマルチスレッドが使用されます。メモリ消費量が少なく、高速かつ効率的なパフォーマンスが得られます。その主な利点は次のとおりです。

  • スレッドは同じアドレス空間を共有します。
  • 糸は軽いです。
  • プロセス間の通信コストは低くなります。
さらに詳しく。

2) スレッドとは何ですか?

スレッドは軽量のサブプロセスです。各スレッドは異なるスタック フレームで実行されるため、これは別個の実行パスになります。プロセスには複数のスレッドが含まれる場合があります。スレッドはプロセス リソースを共有しますが、それでも独立して実行されます。

さらに詳しく。

3) プロセスとスレッドを区別しますか?

プロセスとスレッドには次の違いがあります。

  • 実行中のプログラムはプロセスと呼ばれますが、スレッドはプロセスのサブセットです
  • プロセスは独立していますが、スレッドはプロセスのサブセットです。
  • プロセスはメモリ内に異なるアドレス空間を持ちますが、スレッドには共有アドレス空間が含まれます。
  • コンテキストの切り替えは、プロセスと比較してスレッド間の方が高速です。
  • プロセス間通信は、スレッド間通信よりも遅く、コストがかかります。
  • 親プロセスの変更は子プロセスには影響しませんが、親スレッドの変更は子スレッドに影響を与える可能性があります。

4) スレッド間通信で何がわかりますか?

  • 同期されたスレッド間の通信プロセスは、スレッド間通信と呼ばれます。
  • スレッド間通信は、Java でのスレッド ポーリングを回避するために使用されます。
  • スレッドはクリティカル セクションでの実行を一時停止し、別のスレッドが同じクリティカル セクションに入って (またはロックして) 実行できるようにします。
  • これは、wait()、notify()、およびnotifyAll()メソッドによって取得できます。

5) Java の wait() メソッドの目的は何ですか?

wait() メソッドは、Java の Object クラスによって提供されます。このメソッドは、Java のスレッド間通信に使用されます。 java.lang.Object.wait() は、現在のスレッドを一時停止し、別のスレッドが Notify() メソッドまたは NotifyAll() メソッドを呼び出さなくなるまで待機するために使用されます。その構文を以下に示します。

パブリックfinal void wait()

6) なぜ wait() メソッドを同期ブロックから呼び出す必要があるのですか?

wait メソッドを呼び出す必要があります。そうしないとスローされます。 java.lang.IllegalMonitorStateException 例外。さらに、notify() とnotifyAll() によるスレッド間通信には wait() メソッドが必要です。したがって、正しく正しい通信を行うには、同期ブロックに存在する必要があります。

7) マルチスレッドの利点は何ですか?

マルチスレッド プログラミングには次の利点があります。

  • マルチスレッドにより、アプリケーション/プログラムは、既にいくつかのバックグラウンド タスクを実行している場合でも、入力に対して常に反応することができます。
  • マルチスレッドを使用すると、スレッドが独立して実行されるため、タスクをより高速に実行できます。
  • マルチスレッドを使用すると、スレッドが共通のメモリ リソースを共有するため、キャッシュ メモリの利用率が向上します。
  • マルチスレッドでは、1 台のサーバーで同時に複数のスレッドを実行できるため、必要なサーバーの数が減ります。

8) スレッドのライフサイクルにおける状態は何ですか?

スレッドは、その存続期間中に次のいずれかの状態になる可能性があります。

    新しい：この状態では、new 演算子を使用して Thread クラス オブジェクトが作成されますが、スレッドは生きていません。 start() メソッドを呼び出すまでスレッドは開始されません。実行可能:この状態では、start() メソッドの呼び出し後にスレッドを実行する準備ができています。ただし、スレッドはスレッド スケジューラによってまだ選択されていません。ランニング：この状態では、スレッド スケジューラが準備完了状態からスレッドを選択し、スレッドが実行されます。待機中/ブロック中:この状態では、スレッドは実行されていないがまだ生きているか、他のスレッドが終了するのを待っています。死亡/終了:run() メソッドが終了すると、スレッドは終了状態またはデッド状態になります。

9) プリエンプティブ スケジューリングとタイム スライシングの違いは何ですか?

プリエンプティブ スケジューリングでは、最も優先度の高いタスクは、待機状態またはデッド状態になるか、より高い優先度のタスクが存在するまで実行されます。タイム スライスでは、タスクは事前に定義された時間スライスで実行され、その後、準備完了タスクのプールに再び入ります。次に、スケジューラは、優先度やその他の要因に基づいて、次にどのタスクを実行するかを決定します。

10) コンテキストスイッチングとは何ですか?

コンテキスト切り替えでは、プロセス (またはスレッド) の状態が保存されるため、後で復元して同じ時点から実行を再開できます。コンテキスト切り替えにより、複数のプロセスが同じ CPU を共有できるようになります。

11) Thread を作成するための Thread クラスと Runnable インターフェイスを区別しますか?

スレッドは 2 つの方法で作成できます。

  • Threadクラスを拡張することで
  • Runnableインターフェースを実装することにより

ただし、両方の方法の主な違いは次のとおりです。

  • Java では Runnable インターフェイスの実装中に多重継承が許可されないため、Thread クラスを拡張しても他のクラスを拡張することはできません。 (必要に応じて) 他の基本クラスを拡張することもできます。
  • Thread クラスを拡張することにより、各スレッドは固有のオブジェクトを作成し、Runnable インターフェイスの実装中にそれに関連付けられます。複数のスレッドが同じオブジェクトを共有する
  • Thread クラスは getPriority()、isAlive などのさまざまな組み込みメソッドを提供しますが、Runnable インターフェイスは単一のメソッド、つまり run() を提供します。

12) join() メソッドとは何ですか?

join() メソッドはスレッドが終了するのを待ちます。つまり、参加しているスレッドがタスクを完了するまで、現在実行中のスレッドの実行が停止されます。 Join メソッドは、次の方法で Thread クラスにオーバーロードされます。

  • public void join()throws InterruptedException
  • public void join(long ミリ秒)は InterruptedException をスローします
さらに詳しく。

13) sleep() メソッドの目的と動作について説明します。

Java の sleep() メソッドは、スレッドを特定の時間ブロックするために使用されます。これは、スレッドの実行を特定の時間一時停止することを意味します。それには 2 つの方法があります。

構文：

json 例内の json
  • public static void sleep(long ミリ秒)throws InterruptedException
  • public static void sleep(long ミリ秒、int nanos) は InterruptedException をスローします

sleep() メソッドの動作

sleep() メソッドを呼び出すと、現在のスレッドの実行が一定時間一時停止され、別のスレッド (利用可能な場合) が優先されます。さらに、待機時間が完了すると、前のスレッドの状態が待機状態から実行可能状態に変わり、実行状態になり、プロセス全体が実行が完了しないまで動作し続けます。

14) wait() メソッドと sleep() メソッドの違いは何ですか?

待って（）寝る（）
1) wait()メソッドはオブジェクトクラスに定義されています。sleep()メソッドはThreadクラスで定義されています。
2) wait() メソッドはロックを解放します。sleep() メソッドはロックを解放しません。

15) スレッドを 2 回開始することは可能ですか?

いいえ、スレッドを再起動することはできません。スレッドが開始されて実行されると、Dead 状態になるからです。したがって、スレッドを 2 回開始しようとすると、runtimeException 'java.lang.IllegalThreadStateException' が発生します。次の例を考えてみましょう。

Java配列スライス 
 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(); } }

出力 

 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() の代わりに run() メソッドを呼び出すことはできますか?

はい、run() メソッドを直接呼び出すことは有効ですが、スレッドとしては動作せず、通常のオブジェクトとして動作します。スレッド間でコンテキストの切り替えは行われません。 start() メソッドを呼び出すと、内部で run() メソッドが呼び出され、スレッドの新しいスタックが作成されますが、 run() を直接呼び出しても新しいスタックは作成されません。

さらに詳しく。

17) デーモンスレッドについてはどうですか?

デーモン スレッドは、ユーザー スレッドにバックグラウンド サポートとサービスを提供する優先度の低いスレッドです。プログラムがデーモン スレッドのみに残り、他のすべてのユーザー スレッドが終了または終了した場合、デーモン スレッドは JVM によって自動的に終了されます。 Thread クラスで使用できるデーモン スレッドのメソッドは 2 つあります。

    public void setDaemon(ブールステータス):これは、スレッド デーモン スレッドまたはユーザー スレッドをマークするために使用されます。パブリックブール値 isDaemon():スレッドがデーモンかどうかをチェックします。
さらに詳しく。

18)スレッドが開始された場合、ユーザースレッドをデーモンスレッドとして作成できますか?

いいえ、そうすると、IllegalThreadStateException がスローされます。したがって、デーモン スレッドを作成できるのは、スレッドを開始する前のみです。

 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. } }

出力 

 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)シャットダウンフックとは何ですか?

シャットダウン フックは、JVM がシャットダウンする前に暗黙的に呼び出されるスレッドです。したがって、これを使用して、リソースのクリーンアップを実行したり、JVM が通常または突然シャットダウンしたときに状態を保存したりできます。次の方法を使用してシャットダウン フックを追加できます。

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

シャットダウンフックに関する重要なポイントは次のとおりです。

  • シャットダウン フックは初期化されましたが、JVM シャットダウンが発生した場合にのみ開始できます。
  • シャットダウン フックが実行されない可能性が非常に低いため、シャットダウン フックは Finalizer() よりも信頼性が高くなります。
  • シャットダウンフックは、Runtime クラスの halt(int) メソッドを呼び出すことで停止できます。
さらに詳しく。

20) いつスレッドを中断すべきですか?

スレッドのスリープ状態または待機状態を解除したい場合は、スレッドを中断する必要があります。スレッドを中断するには、interrupt() を呼び出して InterruptedException をスローします。

さらに詳しく。

21) 同期とは何ですか?

同期は、任意の共有リソースへの複数のスレッドのアクセスを制御する機能です。使用されます:

  1. 糸の干渉を防ぎます。
  2. 一貫性の問題を防ぐため。

複数のスレッドが同じタスクを実行しようとすると、誤った結果が生じる可能性があるため、この問題を解決するために、Java は一度に 1 つのスレッドのみを実行できる同期プロセスを使用します。同期は次の 3 つの方法で実現できます。

  • 同期方式による
  • 同期ブロックによる
  • 静的同期による

同期ブロックの構文

 synchronized(object reference expression) { //code block }
さらに詳しく。

22) 同期ブロックの目的は何ですか?

Synchronized ブロックを使用すると、メソッドの特定のリソースで同期を実行できます。特定のリソース上で実行できるスレッドは一度に 1 つだけであり、同期ブロックに入ろうとする他のスレッドはすべてブロックされます。

  • 同期ブロックは、共有リソースのオブジェクトをロックするために使用されます。
  • 同期ブロックの範囲は、それが適用されるブロックに制限されます。その範囲はメソッドよりも小さいです。
さらに詳しく。

23) Java オブジェクトを特定のスレッドによる排他的使用のためにロックダウンできますか?

はい。オブジェクトを「同期」ブロックに入れることで、オブジェクトをロックできます。ロックされたオブジェクトには、それを明示的に要求したスレッド以外のスレッドはアクセスできません。

24) 静的同期とは何ですか?

静的メソッドを同期化すると、ロックはオブジェクトではなくクラスにかかります。メソッドの前に synchronized キーワードを使用すると、オブジェクトがロックされます (一度に 1 つのスレッドがオブジェクトにアクセスできます)。一方、 static synchronized キーワードを使用すると、クラスがロックされます (一度に 1 つのスレッドがクラスにアクセスできます)。さらに詳しく。

25)notify()とnotifyAll()の違いは何ですか?

Notice() は 1 つの待機スレッドのブロックを解除するために使用され、notifyAll() メソッドは待機状態のすべてのスレッドのブロックを解除するために使用されます。

26)行き詰まりとは何ですか?

デッドロックとは、すべてのスレッドが、他の待機スレッドによって保持されているリソースを待機している状況です。この状況では、どちらのスレッドも実行されず、実行される機会も得られません。代わりに、すべてのスレッド間に共通の待機状態が存在します。デッドロックは非常に複雑な状況であり、実行時にコードが破損する可能性があります。

さらに詳しく。

27) デッドロック状態を検出するにはどうすればよいですか?どうすればそれを回避できるでしょうか?

cmd でコードを実行し、スレッド ダンプを収集することでデッドロック状態を検出できます。コードにデッドロックが存在する場合は、cmd にメッセージが表示されます。

Java でデッドロック状態を回避する方法:

    ネストされたロックを回避します。さまざまなスレッドにロックを提供するとデッドロックが発生するため、ネストされたロックがデッドロックの一般的な原因となるため、特定の時点で 1 つのロックを 1 つのスレッドにのみ提供する必要があります。不必要なロックを回避します。必要のないロックは避けなければなりません。スレッド結合の使用:スレッド結合は、別のスレッドが実行を終了するまでスレッドを待機するのに役立ちます。そのため、結合メソッドを最大限に使用してデッドロックを回避できます。

28) Java のスレッド スケジューラとは何ですか?

Java では、スレッドを作成すると、JVM の一部であるスレッド スケジューラの助けを借りてスレッドが監視されます。スレッド スケジューラは、どのスレッドを実行するかを決定することのみを担当します。スレッド スケジューラは、スレッドをスケジュールするために、プリエンプティブとタイム スライシングという 2 つのメカニズムを使用します。

Java スレッド スケジューラは、スレッドに対して次のことを決定するためにも機能します。
  • スレッドの優先順位を選択します。
  • スレッドの待ち時間を決定します
  • スレッドの性質をチェックします

29) マルチスレッド プログラミングでは、各スレッドにスタックがありますか?

はい、マルチスレッド プログラミングでは、すべてのスレッドが互いに独立しているため、すべてのスレッドがメモリ内に独自のスタック領域または個別のスタック領域を維持します。

30) スレッドの安全性はどのようにして実現されますか?

メソッドまたはクラス オブジェクトが競合状態なしに複数のスレッドで同時に使用できる場合、そのクラスはスレッドセーフです。スレッド セーフは、プログラムをマルチスレッド プログラミングで安全に使用できるようにするために使用されます。これは次の方法で実現できます。

  • 同期
  • Volatile キーワードの使用
  • ロックベースのメカニズムの使用
  • アトミック ラッパー クラスの使用

31) 競合状態とは何ですか?

競合状態は、マルチスレッド プログラミングにおいて、さまざまなスレッドが同時に実行され、共有リソースに同時にアクセスするときに発生する問題です。同期を適切に使用すると、競合状態を回避できます。

32) Java の volatile キーワードは何ですか?

volatile キーワードは、スレッド セーフを実現するためにマルチスレッド プログラミングで使用されます。これは、1 つの volatile 変数の変更が他のすべてのスレッドに表示されるため、一度に 1 つのスレッドで 1 つの変数を使用できるためです。

33) スレッドプールから何がわかりますか?

  • Java スレッド プールは、タスクが割り当てられるのを待っているワーカー スレッドのグループを表します。
  • スレッド プール内のスレッドは、プールから 1 つのスレッドを取得し、それにジョブを割り当てるサービス プロバイダーによって監視されます。
  • 指定されたタスクが完了すると、スレッドは再びスレッド プールに戻ります。
  • スレッド プールのサイズは、実行用に予約されているスレッドの総数によって異なります。

スレッド プールの利点は次のとおりです。

arpコマンド
  • スレッド プールを使用すると、パフォーマンスを向上させることができます。
  • スレッド プールを使用すると、システムの安定性が向上します。

同時面接の質問

34) 同時実行 API の主なコンポーネントは何ですか?

同時実行 API は、java.util.Concurrent パッケージのクラスとインターフェイスを使用して開発できます。 java.util.Concurrent パッケージには以下のクラスとインターフェースがあります。

  • 執行者
  • Fark参加プール
  • ExecutorService
  • ScheduledExecutorService
  • 未来
  • 時間単位(列挙)
  • カウントダウンラッチ
  • サイクリックバリア
  • セマフォ
  • スレッドファクトリー
  • ブロッキングキュー
  • 遅延キュー
  • ロック
  • フェイザー

35) Java の同時実行 API の Executor インターフェイスとは何ですか?

パッケージ java.util.concurrent によって提供される Executor インターフェイスは、新しいタスクを実行するために使用される単純なインターフェイスです。 Executorインターフェイスのexecute()メソッドは、特定のコマンドを実行するために使用されます。 execute() メソッドの構文を以下に示します。

voidexecute(実行可能なコマンド)

次の例を考えてみましょう。

 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(); } } } }

出力 

 Running Thread! Thread Completed

36) BlockingQueueとは何ですか?

java.util.concurrent.BlockingQueue は、新しい値を挿入する前にスペースが利用可能になるまで待機する、またはキューから要素を取得する前にキューが空でなくなるのを待機するなどの操作をサポートする Queue のサブインターフェースです。次の例を考えてみましょう。

 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(); } } } }

出力 

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

37) BlockingQueueを使用して生産者と消費者の問題を実装するにはどうすればよいですか?

プロデューサーとコンシューマーの問題は、次の方法で BlockingQueue を使用することで解決できます。

 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 インターフェースと Runnable インターフェースの違いは何ですか?

Callable インターフェイスと Runnable インターフェイスは両方とも、複数のスレッドで実行する必要があるクラスによって使用されます。ただし、両方の間には 2 つの主な違いがあります。

  • Callable インターフェイスは結果を返すことができますが、Runnable インターフェイスは結果を返すことができません。
  • Callable インターフェイスはチェック例外をスローできますが、Runnable インターフェイスはチェック例外をスローできません。
  • Callable インターフェースは Java 5 より前では使用できませんが、Runnable インターフェースは使用できます。

39) Java の同時実行におけるアトミック アクションとは何ですか?

  • アトミック アクションは、他の操作に干渉することなく、タスクの 1 つの単位で実行できる操作です。
  • アトミック アクションはタスク間で停止できません。一度開始すると、タスクの完了後にのみ充填が停止します。
  • a++ などのインクリメント操作では、アトミック アクションは許可されません。
  • プリミティブ変数のすべての読み取りおよび書き込み操作 (long と double を除く) はアトミック操作です。
  • volatile 変数 (long および double を含む) のすべての読み取りおよび書き込み操作はアトミック操作です。
  • アトミック メソッドは java.util.Concurrent パッケージで利用できます。

40) Java の同時実行 API のロック インターフェイスとは何ですか?

java.util.concurrent.locks.Lock インターフェースは同期メカニズムとして使用されます。これは同期ブロックと同様に機能します。ロックと同期ブロックには、以下に示すいくつかの違いがあります。

  • ロック インターフェイスは、待機中のスレッドにアクセスが与えられる順序を保証しますが、同期ブロックはそれを保証しません。
  • ロック インターフェイスには、ロックが許可されない場合のタイムアウトのオプションが用意されていますが、同期ブロックにはタイムアウトのオプションがありません。
  • Lock インターフェイスのメソッド、つまり Lock() と Unlock() は異なるメソッドで呼び出すことができますが、単一の同期ブロックは完全に 1 つのメソッドに含まれている必要があります。

41) ExecutorService インターフェイスについて説明します。

ExecutorService インターフェイスは Executor インターフェイスのサブインターフェイスであり、ライフサイクルを管理する機能を追加します。次の例を考えてみましょう。

 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(); } } } }

出力

アリ対メイブン 
 Shutdown executor shutdown finished

42) スレッドに関する同期プログラミングと非同期プログラミングの違いは何ですか?

同期プログラミング: 同期プログラミング モデルでは、タスクを完了するためにスレッドが割り当てられるため、スレッドはそのタスクでの作業を開始し、割り当てられたタスクが終了した後でのみ他のタスクで使用できるようになります。

非同期プログラミング: 非同期プログラミングでは、1 つのジョブを複数のスレッドで完了できるため、さまざまなスレッドを最大限に活用できます。

43) Java の Callable と Future について何がわかりますか?

Java 呼び出し可能インターフェース: Java5 では、呼び出し可能なインターフェースは java.util.concurrent パッケージによって提供されました。これは Runnable インターフェイスに似ていますが、結果を返すことができ、例外をスローすることもできます。また、スレッドを実行するための run() メソッドも提供します。 Java Callable は Generic を使用するため、任意のオブジェクトを返すことができます。

構文：

パブリックインターフェイス呼び出し可能

Java Future インターフェース: Java Future インターフェースは、同時プロセスの結果を提供します。 Callable インターフェースは java.util.concurrent.Future のオブジェクトを返します。

Java Future では、以下の実装メソッドが提供されています。

    cancel(ブール値。実行中の場合は中断される可能性があります):割り当てられたタスクの実行をキャンセルするために使用されます。得る（）：実行が完了していない場合は時間を待って結果を取得します。isCancelled():タスクが完了前にキャンセルされた場合は true を返すため、ブール値を返します。終わらせる（）：ジョブが正常に完了した場合は true を返し、それ以外の場合は false を返します。

44. ScheduledExecutorService と ExecutorService インターフェイスの違いは何ですか?

ExecutorServcie と ScheduledExecutorService は両方とも java.util.Concurrent パッケージのインターフェースですが、scheduledExecutorService は、Runnable タスクと Callable タスクを遅延または固定期間ごとに実行するための追加メソッドをいくつか提供します。

45) JavaでFutureTaskクラスを定義しますか?

Java FutureTask クラスは、Future インターフェースの基本実装を提供します。結果は 1 つのタスクの実行が完了した場合にのみ取得でき、計算が完了しない場合は get メソッドがブロックされます。実行が完了すると、再開したりキャンセルしたりすることはできません。

構文

public class FutureTask extends Object 実装 RunnableFuture