"Runnableを実装し"vs"のスレッドに"Java

Question

からまさしくかつてないほど過ごしたスレッドJavaでは、がその場で発音を確認することがこの二つの書き方のスレッド:

と implements Runnable:

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

または、 extends Thread:

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

あな差はこれら二つのブロックのコードについて教えてください。

Answer 1

はい：RunnableはIMO、それを行うための好ましい方法である実装します。あなたは本当にスレッドの振る舞いを専門としていません。あなたはそれを実行するために何かを与えています。これは構図を意味して行くには、の哲学の "純粋な" 方法です。

の実用的なの用語では、それはあなたがRunnableを実装し、同様に他のクラスから拡張することができることを意味します。

Answer 2

tl;dr:Runnableを実装するべきであると説かれた。しかし、問題点が重要

一般に、使用をお勧めしよう Runnable よ Thread できるようにするために、お仕事のみ疎結合と選択肢の並行処理.例えば、をご利用の場合 Runnable 決降ることはできませんとで Thread, したりすることも可能ですコthreadA.run().

警告: 周辺のここで強く意欲をそぐような使用の原スレッド）。いほうがずっと好の利用 Callables や FutureTasks からのjavadoc:"で取消可能な非同期計算").の統合のタイムアウト、適切な解約のスレッドプールの並行処理にても便利で私は杭の原スレッド）。

フォロー: があり FutureTask コンストラクタ ることを可能にする使用Runnablesがおすすめの最も快適）のものを現代の並行処理ツールです。 を引用したjavadoc:

必要がない場合は、特定の結果使用を考慮する構造物の形式:

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

なので、まだまだ現役として活躍していを runnable ご threadA, し、次の結果を得た:

new FutureTask<Object>(threadA, null)

別のオプションができる近Runnablesは ThreadPoolExecutor.で利用できます 実行 方法をRunnableを実行"のつまり与えられた課題に対しています。"

だみのスレッドプールのコードフラグメント以上となるには、次のようなものを使用して 執行者.newCachedThreadPool() ファクトリメソッド):

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

Answer 3

この話の教訓ます：

のあなたには、いくつかの動作を上書きする場合にのみ継承します。の

というか、それは次のように読まれるべきである。

のより少ない、インターフェースを継承。の

Answer 4

も数多くの回答を付け加えておきたい。このことは理解 Extending v/s Implementing Thread.
広結合する二つのクラスファイルを非常に注意の大きな要因となりうることが難しい対応。

両方のアプローチの仕事なんですが、ものがあります。
最も一般的差

1. きの延長はスレッドのクラスは、その後できませんの延長のその他のクラスです。(ご存知のとおり、Javaせを受け継ぎりを行っています。-
2. ときにRunnableを実施できる省スペースのためのクラスへのその他のクラスの将来ます。

しかし、一 差 との間の実施並びに延びるスレッドがこの
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.

以下の例のご理解をより明確に

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

出力は、上記のプログラム。

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

のRunnableェアプローチ、インスタンスのクラスがつくられていることがで共有されている別のスレッド）。その値のカウンタを増加された各スレッドがアクセスする

一方で、スレッドのクラスのアプローチが必要になるのを別途インスタンス毎のスレッドがアクセスするそのため異なるメモリの割り当てのための各クラスのインスタンスは、それぞれ別々のカウンタの値が同じなの増加が起こると見られることから、大きなオブジェクト参照が同じです。

するために使用されRunnable?
使用のRunnableインタフェースにアクセスすれば、同じリソースグループからのスレッド）。の利用を避けるスレッドのクラスで、ここで複数のオブジェクトを作成消費メモリー使用されている性能オーバーヘッド。

クラスを実装するRunnableはスレッドだけます。たRunnableなスレッドを作成する必要がありますインスタンスのスレッドを通す場合そのものにしています。

多くの場合、そのRunnableインタフェース使用の場合は予定をオーバーライド run() 方法は他のスレッドます。ですので、この点は重要で授業をすべきでないサブクラス化のない限り、プログラマーを修正または拡張の基本的な動作のクラスです。

る必要がある場合、このスーパークラス、実装は、Runnableインタフェースはより適切なもので、複数のスレッドのクラスです。できますので延長するクラスの実践によるRunnableインタフェースでフィルタリングます。

って欲しいと願っていま！！

Answer 5

私はまだ言及されていない驚いたことの一つは、Runnableを実装するクラスがより柔軟になるということです。

あなたがスレッドを拡張する場合は、

あなたがやっている行動は常にスレッドであることを行っています。しかし、あなたがRunnableを実装する場合、それはする必要はありません。あなたは、スレッドでそれを実行し、またはエグゼキュータのサービスのいくつかの種類に渡し、または単に（多分後で実行することが、同じスレッド内で）シングルスレッドのアプリケーション内のタスクとして、それを周りに渡すことができます。あなたはちょうどあなたがRunnableために自分自身を結合した場合よりもThreadを使用する場合のオプションは、より多くの開いています。

Answer 6

したい場合は実装または拡大するその他のクラスその後 Runnable インタフェースが最も好ましい、そうでない場合はたくない場合は他のクラスを延長又は実施し Thread クラスすることが好ましい。

最も一般的差

き extends Thread クラスは、その後できませんの延長のその他のクラスです。(ご存知のとおり、Javaせを受け継ぎりを行っています。-

き implements Runnable, 保存することができる空間のクラスへのその他のクラスの将来ます。

• Javaをサポートしていない複数の答することができますを長くするだけでなく、一つはJavaのクラスまで延長のスレッドのクラスを落としてしまったチャンスは拡張、または継承クラスJava.

• オブジェクト指向プログラミングの拡張クラス"という意味で、一般的には、新しい機能、改変、改善行動です。ない場合には、変更のスレッド使用のRunnableタです。

• Runnableインタフェースにタスクを実行できる平野のスレッドまたは執行者またはその他の。で論理的分離のタスクとしてRunnable以外のスレッドがデザイン決定します。

• 分離課題としてRunnable手段として再利用することも可能で、タスクの自由で実施するための異なる。はできませんので再スタースレッドまでが完了します。再Runnable vsスレッドのための課題では、Runnableは優勝となります。

• Javaのデザイナーと認識し、その執行者受け入れRunnableとしてタスクをやって労働者のスレッドを実行する方です。

• を継承すべてのスレッドの方法が追加架かを表すためのタスクを実行できるとのRunnable.

送迎から javarevisited.blogspot.com

これらの顕著な違いのスレッドにRunnable Java.まっている場合その他の違いのスレッドvs Runnableてくださを共有した。私が個人的に利用したRunnable以上のスレッドがこのシナリオとして使用Runnableは呼び出し可能オブジェクトインタフェースへのご要件を満たす。

しかし、大きな違いです。

き extends Thread クラスは、それぞれのスレッドを作成し、独自のオブジェクトと連付けます。き implements Runnable, で株式が同じオブジェクトを複数のスレッド）。

Answer 7

実は、その比較 Runnable や Thread ます。

この二ついての依存関係とマルチスレッディングのように Wheel and Engine 関係のモーター車両です。

私の言うとおりに切りのためのマルチスレッドに二段がある。作らせて頂いています。ちょっと思ったものですから。

Runnable:
実施にあたって interface Runnable これを作成するものであ run able 異なるねじになります。今何かを作り出すことで実行中のthread(runnable内のスレッドな意味を作ります。
そのクラス MyRunnable でも普通のシェイクスピアの"マクベス" void run 方法。でフラッシュすることはありませんか普通のオブジェクトのみの方法 run る実行が正常に呼び出されます。(ない限り、それは、オブジェクトスしてはなりません。

スレッド:
class Thread, んじゃないでしょうかは非常に特別なクラスを維持し、近代化する機能を始めるための新しいスレッドで実際に可能-マルチスレッディングを通じて start() 方法。

なぜないのが賢明と比較?
しておくことが必要不可欠であるもののためのマルチスレッドに対応.

のためのマルチスレッドに対しては二つのことをやろうとしてい

• できるものを実行中のThread(Runnable).
• できるものを新しいスレッドのThread.

で技術的-理論の両方が必要なの開始にスレッド、 走 やま で対応してい （ Wheel and Engine モーターの動します。

その理由を開始することはできませんのスレッドと MyRunnable 渡す必要がありまでのインスタンス Thread.

が を作成することができ、実行スレッドのみを使用 class Thread がクラス Thread 具 Runnable しか Thread または Runnable ます。

最後に Thread や Runnable して補うためにお互いmultithreadingない競技者又は交換できます。

Answer 8

あなたはRunnableを実装する必要がありますが、あなたは、Java 5以降で実行している場合、あなたはnew Threadでそれを開始したが、<のhref = "https://docs.oracle.com/javase/8/docs/を使うべきではありませんAPI / Javaの/ utilに/同時/ ExecutorService.html」のrel = "noreferrer"> ExecutorServiceのの代わりに。詳細については以下を参照してください。のJava の中で、単純なスレッドを実装する方法

Answer 9

私は専門家ではないんだけど、私はRunnableを実装する一つの理由を考える代わりにスレッドを拡張することができます。Javaは唯一の単一継承をサポートしていますので、あなただけの1クラスを拡張することができます。

編集：これは、もともと「インターフェースを実装することは少ないリソースを必要とします。」と述べました同様に、しかし、あなたは新しいスレッドのインスタンスにいずれかの方法を作成する必要があるので、これは間違っていた。

Answer 10

私は三番目の方法があると言うでしょう。

public class Something {

    public void justAnotherMethod() { ... }

}

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

多分これは、JavascriptとActionScriptの3の私の最近の大量使用によってビットに影響を与えているが、この方法は、あなたのクラスはRunnableのようなかなり漠然とインタフェースを実装する必要はありません。

Answer 11

のJava 8のリリースに伴い、第三の選択肢は今があります。

Runnableは機能インタフェースに、ありますそのインスタンスは、ラムダ式やメソッドの参照を使用して作成することができることを意味します。

あなたの例では、置き換えることができます：

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

またはあなたがExecutorServiceとメソッドのリファレンスを使用する場合：

executor.execute(runner::run)

これらは、はるかに短いあなたの例よりもないですが、また、あなたがスレッドの振る舞いを専門としていないので、そのような単一の責任として、Runnable上Threadを使用して組成物を使用する他の回答に記載された利点の多くが付属しています。この方法ではまた、あなたの例でそうであるように、あなたが必要とするすべてのRunnableであれば、余分なクラスを作成避けます。

Answer 12

インタフェースをインスタンス化することはあなたのコードとスレッドの実装との間にきれいに分離を与えるので、私はこのケースではRunnableを実装することを好むと思います。

Answer 13

誰もがここでのRunnableを実装する移動するための方法であると私は実際にそれらに反対していないが、あなたは、ソートのコード内でそれを証明している実際には、私の意見でスレッドを拡張する場合もあることを考えているようです。

：あなたはRunnableを、スレッド名を管理していない実装するクラスをRunnableをを実装する場合は、

、それはそうのように、スレッド名を設定することができ、呼び出し元のコードであります

new Thread(myRunnable,"WhateverNameiFeelLike");

しかし、あなたがスレッドを拡張する場合、あなたは（ちょうどあなたの例のように、あなたがスレッドのThreadBを「名前）クラス自体の中にこれを管理するために得ます。この場合、あなたます：

A）デバッグの目的のためにそれをより便利な名前を与えるかもしれない。

B）あなたはそれがスレッドであるという事実を無視し、それが実行可能であるかのようにして上記の操作を行う場合を除き（その名前は、そのクラスのすべてのインスタンスを使用することを余儀なくされているが、我々はここにで大会について話しています場合は、私は）感じている可能性を無視することができます。

あなたも、例えばその作成のスタックトレースを取得し、スレッド名としてそれを使用する場合があります。これは奇妙に思えるが、あなたのコードは、それはデバッグ目的のために非常に役立ちます構成されている方法に応じて可能性があります。

これは小さなことのように思えるかもしれないが、あなたは、スレッドの多くの非常に複雑なアプリケーションを持っていると、突然、物事のすべてが、どのネットワークプロトコルであるため、欠陥のデッドロックの理由のためか、おそらくどちらか（「停止している」ところそれほど明らかであろう - ）、または他の無限の理由その後、すべてのスレッドが「スレッド2」、「スレッド-1」と呼ばれるJavaからスタックダンプを取得し、「スレッド-3」は常に非常に有用ではありません（それがどのように依存しますあなたのスレッドが構成されている、あなたが有効であるかどうかを伝えることができただけでそのスタックトレースによる - 。あなたが複数のスレッドのグループで同じコードを実行しているすべて）を使用していないことは常に可能ならば、

は、あなたはもちろん、その作成の呼び出しのスタックトレースに名前を設定し、スレッドクラスの拡張を作成することにより、一般的な方法で上記の操作を行い、その後、あなたのRunnableを実装の代わりに、標準であることを使用することができることを言いましたそれは例えば、処理可能性がJavaのThreadクラス（下記参照）が、スタックトレースに加えて、デバッグのためのスレッド名に有用であろう多くのコンテキスト固有の情報があるかもしれません（多くのキューまたはソケットの1を参照する。その場合、あなたの中にあなたが（または他の人があなたのライブラリを使用して）コンパイラの力を持つことができるように、特定の情報の名前で使用するため（問題の例：キュー/ソケット））に合格するような場合のために特別にスレッドを延長することを好むかもしれません。

ここでは、その名のように呼び出しスタックトレースを持つ一般的なスレッドの例です

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

、ここでは二つの名前を比較出力のサンプルです

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]

Answer 14

Runnableするためには、多くの

• 葉より柔軟に Runnableの実施の延長 別のクラス
• 分離し、コードから 執行
• して走行させることを可能にする自 runnableからのスレッドプール、 イベントスレッド、又は他のいずれかの方法によって、 ます。

ものが必要ない場合でもその名を知られています。がありませんの利益をオーバースレッド、Runnableはより良い解決策です。

Answer 15

これは非常に人気の話題の答えを広げるべて、深みのあいすることが正当にコンパイルの良さからの回答その他、より簡潔な形になっていますので、新しく先の概要:

1. 通常、あなたが、このクラスの追加や修正が可能です。なので、 したくない場合 へ 上書き 他の スレッドの挙動, を使用し、Runnable.

2. 同一の光 必要がない場合 へ 継承 スレッドの方法ができない 架 用のRunnable.

3. 単相続:を伸ばすスレッドはできませんから新たな方法論を提供することその他のクラスは、これに必要な使用Runnable.

4. では良いデザインを分離ドメイン理論から技術的手段は、その意味ではしていることが望ましい、Runnableタスク 単離 ご タスクから ご ランナー.

5. ができ 実行 同Runnable オブジェクトを複数回, スレッドオブジェクト、しかし、できるだけが開始されます。もしそうにな執行者なRunnablesがないスレッド）。)

6. を開発すればあなたの仕事としてRunnableす すべての柔軟性ので、使い方を今後とも.ついての同時実行によ執行者によるねじになります。もまでも利用で非同時に同一のスレッドとその他の経常タイプ/オブジェクトです。

7. これはとても容易になりま 別 タスク-ロジックおよび並行処理 側面に ご ユニットテスト.

8. ご興味のある方に質問されることもありますので、も併せて関心を持っており、 差呼び出し可能オブジェクトは、Runnable.

Answer 16

スレッドを拡張したRunnableの実装の違いは次のとおり

の

"ここに画像の説明を入力します。

Answer 17

このは、Oracleので議論されるスレッドのチュートリアルの定義と起動>

  

あなたはこれらの慣用句のどちらを使うべきか？採用第イディオム、   Runnableオブジェクト、Runnableオブジェクトをすることができるので、より一般的です   スレッド以外のクラスをサブクラス化。二イディオムは、使用する方が簡単です   シンプルなアプリケーションでは、しかし、あなたの仕事という事実によって制限されています   クラスはスレッドの子孫でなければなりません。このレッスンでは、最初に焦点を当てて   スレッドオブジェクトからのRunnableタスクを分離するアプローチ、   それは、タスクを実行します。だけでなく、このアプローチは、より柔軟ですが、   それがカバーされ、高レベルのスレッド管理APIに適用されます   後でます。

つまり、あなたのクラスがRunnable以外のクラスを拡張シナリオで動作しますThreadを実装します。 Javaは多重継承をサポートしていません。ハイレベルスレッド管理APIの一部を使用する場合にも、Threadを拡張することはできません。延びるThreadが好ましい唯一のシナリオは、将来のアップデートの対象とならない小さなアプリケーションです。あなたのプロジェクトの成長に合わせて、より柔軟性があるとしてRunnableを実装するために、ほとんど常により良いです。設計変更は、Javaで多くのインターフェイスを実装することができますとして大きな影響力を持っていますが、一つだけのクラスを拡張しません。

Answer 18

ていただく場合が誤っていないので、似たようなものを

の違いは何ですかインターフェースや抽象クラス?

extends"を設立は"関係&インタフェース"は"能力です。

好 Runnableを実装し :

1. ない場合に伸ばすスレッドのクラス変更のスレッドAPIのデフォルトの実装
2. の場合の実行中に火災を忘れると、コマンド
3. 生き延びる別のクラス

。"extendsスレッド" :

1. していればオーバーライドこれらの スレッド 方法として掲載oracleドキュメンテーションページ

一般的なオーバーライドのスレッドを構築します。なので Runnableを実装し が好ましたのです。

一方で、先進 ExecutorService または ThreadPoolExecutorService APIの提供をより柔軟性と制御が可能となります。

このSEの質問:

ExecutorService vsカジュアルスレッドSpawner

Answer 19

最も簡単な説明と実施 Runnable して割り当てが同じオブジェクトを複数のスレッドの各 Thread 株式と同じオブジェクト状態と行動です。

たとえば、あるスレッド、 thread1 を整数配列、 thread2 かを整数の配列が、配列がいっぱいになってしまった。通知するためには、 thread2 仕事での配列か thread1 していただくためです。

の実施 Runnable できる柔軟性をオブジェクトに対し extends Thread す新しいオブジェクトの各スレッドがアップデートのこのように、thread1により失われてthread2.

Answer 20

Runnableを実装からThreadクラスの分離はまた、スレッドとrun（）メソッドとの間の潜在的な同期の問題を回避します。別のRunnableは、一般に実行可能コードを参照して実行される方法に柔軟性を与える。

Answer 21

ことになるの S の 固体:単一の責任です。

A スレッド 現在の 走行キ （実行コンテキスト:スタックフレーム、スレッドid、等) の 非同期実行 作品"と呼ぶに相応しいコードです。その 作品コード 理想的には同一にしなければなり実施するかどうか 同期 または 非同期.

だって一緒に一つの実装をロードしておく必要がありまに二つのオブジェクト 関係のない 原因の変化：

1. スレッドの取り扱いにご応募い。照会及び修正の実行コンテキスト)
2. アルゴリズムを実装をコード（runnable）

の場合の言語を使用支援部分の授業または複数の相続きますので、その要因を分離し独自のスーパークラスですが、突き詰めと同じ構成では、二つのオブジェクトが、その機能を設定しない部分が重なっているのです。ことになるための理論。

実際には、一般的に、プログラムなより複雑以上が必要です。お持ちの方のスレッドの作業に特定のタスクな変化は、その作業は、ほかにあまりないであろう点では課題別のクラスに、コードより簡単になります。

この Java, ての設備 あ, かりやすいと言え始めと直接単体 Runnable 授業は、すでにご存じの通り、インスタンスを Thread （ Executor)インスタンス.一度 使用 このパターンではなく使用していなくても(read)は、単にrunnableのスレッド。

Answer 22

あなたがインターフェイスを実装するのではなく、基本クラスを拡張したいと思います一つの理由は、すでにいくつかの他のクラスを拡張していることです。あなただけの1つのクラスを拡張することができますが、任意の数のインターフェイスを実装することができます。

あなたがスレッドを拡張する場合は、

、あなたは基本的に「この」以外のスレッドが実行するロジックを防止しています。あなただけのロジックを実行するには、のいくつかののスレッドをしたい場合は、それだけでRunnableを実装する方が良いでしょう。

Answer 23

あなたが実行可能に使用している場合、あなたの他のクラスのいずれかに拡張するためのスペースを節約することができます。

Answer 24

私たちは私たちのクラスはThreadとして動作するように望んでいた基本的な理由を再訪問することはできますか？ 理由は全く、私達はちょうどタスクを実行したい、正確終了が早く、または待機しない場合があります場合は、タスクの実行はメイン・スレッドとメインスレッドから分岐しなければならないことを意味し、非同期モード、で最も可能性が高いがありません分岐パス（タスク）のための

これは全体の目的である場合は、

、そして、どこで、特殊なスレッドの必要性を確認します。これは、システムのスレッドプールからRAWスレッドをピックアップし、それを私たちのタスクを割り当てることによって達成することができます（私たちのクラスのインスタンスでもよい）と、それはそれでます。

だから、私たちはOOPSの概念に従うと、我々が必要とするタイプのクラスを書いてみましょう。正しい方法の問題でそれをやって物事を行うには多くの方法があります。

私たちは、タスクを必要とするので、スレッド上で実行することができるタスク定義を記述します。だから、Runnableを使用します。

を常に覚えてimplementsが特別行動を付与するために使用され、extendsは機能/性能を付与するために使用されます。

私たちは、代わりに私たちは私たちのクラスを実行することができますタスクとして動作するようにしたい、スレッドのプロパティを望んでいない。

Answer 25

はい、 あなたがスレッドAコールを呼び出した場合は、startメソッドを呼び出す必要はありませんし、runメソッドがコールされた後にのみ、スレッドAクラスを呼び出します。 ThreadBコールを使用している場合しかし、その後のコールrunメソッドのために必要なスタートスレッドにする必要があります。 あなたが任意のより多くの助けを持っている場合は、私に返事ます。

Answer 26

私は言及したすべての理由でのRunnableを使用するのが最も便利です見つけるが、時々私は私自身のスレッドを停止する方法を作成して、私が作成したスレッド上で、それを直接呼び出すことができるようにスレッドを拡張したい。

Answer 27

あなたはThreadクラスを拡張するならば、他のクラスが拡張されませんので、

Javaは、複数の継承をサポートしていません。

例：あなたはアプレットを作成する場合、それを行う必要があり、スレッドを作成するための唯一の方法は、

、Runnableインタフェースを実装することであるので、ここでAppletクラスを拡張

Answer 28

Runnableこのインタフェースを実装するクラスである

Threadは、インタフェースです。設計の観点からは、タスクが定義されている方法の間で、それがどのように実行されるかの間に明確な分離があるはずです。前者はRunnalbe実装の責任であり、後者はThreadクラスの仕事です。 Runnableの実施例ほとんどでフォローする正しい方法です。

Answer 29

スレッドと実行可能違い 私たちは、その後、Threadクラスを使用して、我々が作成されたオブジェクトの数に等しいスレッドの数をスレッドを作成している.IF。 私たちは、Runnableインタフェースを実装することで、スレッドを作成している場合、我々はそれが

より少ないメモリを取るThread.So単一のオブジェクトを複数で共有されているthread.So複数を作成するための単一のオブジェクトを使用することができます 我々のデータは、高感度に影響はない場合、

だから、要件に応じて、。だから、私たちは、Runnableインタフェースを使用することができ、複数のスレッド間で共有することができます。

Answer 30

の追加にあたっては、自分のセントをここに- 常に可能な限りの利用 implements Runnable .以下の二点に理由を利用するべきではありません extends Threads

1. 理想的にはアナフィラキシー様のスレッドのクラスの Thread クラスすべき final.少なくともその方法のように thread.getId().見 この 議論のためのバグ関連の拡張 Threads.

2. したい方にパズルを解決できるのも面効果を張ります。以下のコード のまま印刷到達不能コードが無人に通知します。

をご覧ください http://pastebin.com/BjKNNs2G.

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