Java中的“可运行的实现”与“扩展线程”

从什么时候开始在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

这两个代码块有什么显着区别吗？

#1楼

我发现出于所有上述原因使用Runnable最为有用，但有时我喜欢扩展Thread，以便可以创建自己的线程停止方法并直接在创建的线程上调用它。

#2楼

Java不支持多重继承，因此，如果您扩展Thread类，则不会扩展任何其他类。

例如：如果创建一个applet，那么它必须扩展Applet类，因此这里创建线程的唯一方法是实现Runnable接口

#3楼

这里的每个人似乎都认为实现Runnable是必经之路，我并不完全不同意它们，但是在我看来，还有一种扩展Thread的情况，实际上您已经在代码中进行了演示。

如果实现Runnable，则实现Runnable的类无法控制线程名称，它是可以设置线程名称的调用代码，如下所示：

new Thread(myRunnable,"WhateverNameiFeelLike");

但是如果扩展Thread，则可以在类本身中进行管理（就像在示例中将线程命名为“ ThreadB”一样）。在这种情况下，您：

A）可能会给它起一个更有用的名称以用于调试

B）强制将该名称用于该类的所有实例（除非您忽略它是线程的事实并对其进行处理，就好像它是Runnable一样，但是无论如何我们都在这里讨论约定，可以忽略我的那种可能性）。

您甚至可能例如跟踪其创建的堆栈跟踪，并将其用作线程名。这可能看起来很奇怪，但是取决于代码的结构，对于调试目的可能非常有用。

这看起来似乎是一件小事，但是如果您有一个非常复杂的应用程序，其中包含许多线程，并且突然之间所有操作都已“停止”（由于死锁的原因或可能是由于网络协议中的缺陷所致，这种缺陷会更少很明显-或其他无尽的原因），然后从Java中获取所有线程都称为'Thread-1'，'Thread-2'，'Thread-3'的堆栈转储并不总是很有用（这取决于线程的使用方式）结构化的信息，以及是否可以仅通过堆栈跟踪有效地分辨出哪个-如果使用的是多个都运行相同代码的多线程组，则并非总是可能的。

话虽这么说，您当然也可以通过创建线程类的扩展名（通过将其名称设置为其创建调用的堆栈跟踪），然后将其与您的Runnable实现（而不是标准的Java Thread类）一起使用来以常规方式执行上述操作（请参见下文），但除了堆栈跟踪信息外，可能还有更多特定于上下文的信息，这些信息将在线程名中用于调试（例如，对它可能处理的许多队列或套接字之一的引用），在这种情况下，您可能更喜欢专门针对这种情况扩展Thread，以便您可以让编译器强迫您（或其他使用您的库的）传递某些信息（例如，所涉及的队列/套接字）以用作名称。

这是一个以调用堆栈跟踪作为名称的通用线程的示例：

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-MainTestat DebuggableThread.getStackTrace(DebuggableThread.java:6)at DebuggableThread.<init>(DebuggableThread.java:14)at DebuggableThread.main(DebuggableThread.java:19)
,5,main]

#4楼

Runnable是一个接口，而Thread是实现此接口的类。从设计的角度来看，应该在如何定义任务和如何执行任务之间有明确的区分。前者是Runnalbe实现的责任，后者是Thread类的职责。在大多数情况下，实现Runnable是遵循的正确方法。

#5楼

这么多好答案，我想补充一点。这将有助于了解Extending v/s Implementing Thread 。
扩展非常紧密地绑定了两个类文件，可能会导致很难处理代码。

两种方法执行相同的工作，但是存在一些差异。
最常见的区别是

当您扩展Thread类时，之后便无法扩展您需要的任何其他类。（您知道，Java不允许继承多个类）。
当实现Runnable时，可以为您的类节省空间，以在将来或现在扩展任何其他类。

但是，实现Runnable和扩展Thread之间的一个重要区别是
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 threadThread t2 = new Thread(rc);t2.start();Thread.sleep(1000); // Waiting for 1 second before starting next threadThread 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 threadExtendsThread tc2 = new ExtendsThread();tc2.start();Thread.sleep(1000); // Waiting for 1 second before starting next threadExtendsThread tc3 = new ExtendsThread();tc3.start();}
}

上面程序的输出。

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

在Runnable接口方法中，仅创建一个类的实例，并且该实例已由不同线程共享。因此，每次线程访问时，counter的值都会增加。

鉴于使用Thread类的方法，您必须为每个线程访问创建单独的实例。因此，为每个类实例分配不同的内存，并且每个实例都有单独的计数器，其值保持不变，这意味着不会增加，因为没有一个对象引用是相同的。

什么时候使用Runnable？
要从线程组访问相同的资源时，请使用Runnable接口。避免在这里使用Thread类，因为创建多个对象会消耗更多的内存，并且会增加性能开销。

实现Runnable的类不是线程，而只是一个类。为了使Runnable成为线程，您需要创建Thread的实例并将其自身作为目标传递。

在大多数情况下，如果您仅打算覆盖run()方法而没有其他Thread方法，则应使用Runnable接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应将类归为子类。

当需要扩展超类时，实现Runnable接口比使用Thread类更合适。因为我们可以在实现Runnable接口以创建线程时扩展另一个类。

我希望这个能帮上忙！

#6楼

这就是SOLID的S ：单一职责。

线程体现了一段代码的异步执行的运行上下文 （例如在执行上下文中：堆栈框架，线程ID等）。理想情况下，这段代码应该是相同的实现，无论是同步还是异步。

如果将它们捆绑在一起在一个实现中，则会为生成的对象提供两个无关的更改原因：

应用程序中的线程处理（即查询和修改执行上下文）
由一段代码（可运行部分）实现的算法

如果您使用的语言支持部分类或多重继承，则可以将每个原因归为它自己的超类，但是归结为与组成两个对象相同，因为它们的功能集不重叠。这是理论上的。

实际上，一般而言，程序不需要携带不必要的复杂性。如果您有一个线程在执行一项特定任务，而又从未更改过该任务，那么将这些任务划分为单独的类可能没有任何意义，并且您的代码将更加简单。

在Java上下文中，由于该功能已经存在 ，因此直接从独立的Runnable类开始并将它们的实例传递给Thread （或Executor ）实例可能更容易。一旦习惯了这种模式，使用（甚至读取）就不会比简单的可运行线程的情况更难。

#7楼

如果要实现或扩展任何其他类，则最好使用Runnable接口，否则，如果不希望扩展或实现任何其他类，则最好使用Thread类。

最常见的区别是

当您extends Thread类时，之后便无法扩展任何其他所需的类。（您知道，Java不允许继承多个类）。

当implements Runnable ，可以为您的类节省空间，以在将来或现在扩展任何其他类。

Java不支持多重继承，这意味着您只能在Java中扩展一个类，因此一旦扩展Thread类，您将失去机会，无法扩展或继承Java中的另一个类。
在面向对象的编程中，扩展类通常意味着添加新功能以及修改或改善行为。如果我们不对Thread进行任何修改，请改用Runnable接口。
可运行接口表示可以通过普通线程或执行程序或任何其他方式执行的任务。因此，将Task与Runnable进行逻辑上的分离比选择Thread是一个好的设计决策。
将任务分隔为可运行意味着我们可以重用任务，也可以通过不同的方式来执行它。因为您无法在线程完成后重新启动它。再一次，Runnable vs Thread完成任务，Runnable获胜。
Java设计人员意识到了这一点，这就是执行器接受Runnable作为Task的原因，并且他们拥有执行这些任务的工作线程。
继承所有Thread方法是额外的开销，仅用于表示可以通过Runnable轻松完成的Task。

由javarevisited.blogspot.com提供

这些是Java中Thread和Runnable之间的一些显着差异。如果您知道Thread与Runnable的其他区别，请通过评论分享。在这种情况下，我个人使用Runnable over Thread，并建议根据您的要求使用Runnable或Callable接口。

但是，明显的区别是。

extends Thread类时，每个线程都会创建一个唯一的对象并与之关联。当您implements Runnable ，它将同一对象共享给多个线程。

#8楼

您想要实现接口而不是扩展基类的原因之一是您已经在扩展其他类。您只能扩展一个类，但是可以实现任何数量的接口。

如果扩展Thread，则基本上是在阻止逻辑由“ this”以外的任何其他线程执行。如果只希望某个线程执行您的逻辑，则最好只实现Runnable。

#9楼

如果使用runnable，则可以节省空间以扩展到其他任何类。

#10楼

我们是否可以重新访问我们希望类充当Thread的基本原因？根本没有理由，我们只是想执行一个任务，很可能是在异步模式下执行，这恰好意味着该任务的执行必须从我们的主线程中分支出来，并且如果提早完成，主线程可能会或可能不会等待用于分支路径（任务）。

如果这是全部目的，那么我在哪里看到需要专门的线程。这可以通过从系统的线程池中选择一个RAW线程并将其分配给我们的任务（可能是我们类的实例）来完成。

因此，让我们遵循OOPs概念并编写所需类型的类。做事有很多方法，以正确的方式做事很重要。

我们需要一个任务，因此编写一个可以在线程上运行的任务定义。因此，请使用Runnable。

永远记住， implements专门用于赋予行为，而extends则用于赋予特征/特性。

我们不想要线程的属性，而是希望我们的类表现为可以运行的任务。

#11楼

Oracle的“ 定义和启动线程”教程中对此进行了讨论：

您应该使用以下哪些习语？第一个使用Runnable对象的习惯用法更为通用，因为Runnable对象可以继承Thread以外的其他类。第二种习惯用法在简单的应用程序中更易于使用，但由于您的任务类必须是Thread的后代而受到限制。本课重点讨论第一种方法，该方法将Runnable任务与执行该任务的Thread对象分开。这种方法不仅更灵活，而且适用于稍后介绍的高级线程管理API。

换句话说，在您的类扩展了Thread其他类的情况下，实现Runnable将起作用。 Java不支持多重继承。同样，在使用某些高级线程管理API时，无法扩展Thread 。最好选择扩展Thread的唯一情况是在小型应用程序中，该应用程序将来将不会进行更新。实施Runnable几乎总是更好，因为随着项目的增长它更加灵活。设计更改不会产生重大影响，因为您可以在Java中实现许多接口，而仅扩展一个类。

#12楼

由于这是一个非常受欢迎的话题，并且好的答案被广泛传播并得到了深入的处理，因此我认为将其他人的好的答案整理成更简洁的形式是合理的，因此新手可以轻松地进行以下概述：

通常，您可以扩展一个类来添加或修改功能。因此， 如果您不想 覆盖任何Thread行为 ，请使用Runnable。
同样， 如果您不需要 继承线程方法，则可以通过使用Runnable来避免这些开销。
单继承 ：如果扩展Thread，则不能从任何其他类扩展，因此如果需要这样做，则必须使用Runnable。
将领域逻辑与技术手段分开是一种很好的设计，从这种意义上讲，最好有一个Runnable任务，将您的任务与运行 者 隔离开 。
您可以多次执行同一个Runnable 对象，但是Thread对象只能启动一次。（也许是原因，执行器为什么接受Runnable，但不接受Thread。）
如果您将任务开发为可运行的， 那么现在和将来都有使用它的灵活性 。您可以通过Executors和Thread同时运行它。而且，您仍然可以像在任何其他普通类型/对象中一样在同一线程中非并行使用/调用它。
这也使得在 单元测试中 分离任务逻辑和并发方面变得更加容易。
如果您对此问题感兴趣，则可能还对Callable和Runnable之间的区别感兴趣。

#13楼

Thread和runnable之间的区别。如果我们使用Thread类创建Thread，则线程数等于我们创建的对象数。如果我们通过实现runnable接口来创建线程，则可以使用单个对象创建多个线程，因此单个对象被多个Thread共享，因此它将占用更少的内存

因此，根据要求，如果我们的数据不敏感。因此它可以在多个Thread之间共享，我们可以使用Runnable接口。

#14楼

将Thread类与Runnable实现分开还可以避免线程与run（）方法之间的潜在同步问题。通常，单独的Runnable在引用和执行可运行代码的方式上通常具有更大的灵活性。

#15楼

这个故事所讲的道德：

仅在要覆盖某些行为时才继承。

更确切地说，应将其理解为：

继承少，接口多。

#16楼

随着Java 8的发布，现在有了第三种选择。

Runnable是一个功能性接口，这意味着可以使用lambda表达式或方法引用创建其实例。

您的示例可以替换为：

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

或者，如果您想使用ExecutorService和方法参考：

executor.execute(runner::run)

这些不仅比您的示例短得多，而且还具有使用Runnable不是Thread其他答案所陈述的许多优点，例如单一职责和使用组合，因为您没有专门研究线程的行为。如果您只需要像示例中那样运行一个Runnable ，这种方法还可以避免创建额外的类。

#17楼

在这里加两分钱- 始终尽可能使用implements Runnable 。 以下是关于为什么不应该使用extends Thread的两个警告：

理想情况下，您永远不要扩展Thread类。 Thread类应该设为final 。至少它的方法如thread.getId() 。有关扩展Thread的错误，请参见此讨论。
那些喜欢解决难题的人可以看到扩展Thread的另一种副作用。当没有人通知时，以下代码将显示无法访问的代码。

请参阅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;}@Overridepublic 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 {@Overridepublic void run() {System.out.println("Do Nothing ");}}
}

#18楼

可运行，因为：

为Runnable实现留出更多灵活性来扩展另一个类
将代码与执行分开
允许您从线程池，事件线程或将来以任何其他方式运行可运行对象。

即使您现在不需要这些，将来也可能。由于覆盖线程没有任何好处，因此Runnable是更好的解决方案。

#19楼

实际上，将Runnable和Thread相互比较是不明智的。

这两个在多线程中具有依赖关系，就像汽车的“ Wheel and Engine关系一样。

我要说，只有两个步骤的多线程方法。让我说清楚。

可运行的：
当实现interface Runnable ，意味着您正在创建run able在其他线程中run able 。现在创建可以在线程内运行（可在线程内运行）的东西，并不意味着要创建线程。
因此，类MyRunnable只是具有void run方法的普通类。它的对象将是一些普通对象，仅run方法，该方法在调用时将正常执行。（除非我们在线程中传递对象）。

线：
class Thread ，我会说这是一个非常特殊的类，具有启动新的Thread的能力，该线程实际上可以通过其start()方法启用多线程。

为什么不明智地进行比较？
因为我们都需要它们都具有多线程功能。

对于多线程，我们需要两件事：

可以在线程（可运行）中运行的东西。
可以启动新线程（线程）的东西。

因此，从技术上和理论上来说，它们都是启动线程所必需的，一个线程将运行，一个线程将使其运行 （例如Wheel and Engine汽车Wheel and Engine ）。

这就是为什么无法使用MyRunnable启动线程， MyRunnable需要将其传递给Thread实例的原因。

但是可以只使用class Thread类来创建和运行class Thread因为Class Thread实现了Runnable因此我们都知道Thread在内部也是Runnable 。

最后， Thread和Runnable相互补充，形成了多线程而不是竞争者或替代者。

#20楼

最简单的解释是通过实现Runnable我们可以将同一对象分配给多个线程，并且每个Thread共享相同的对象状态和行为。

例如，假设有两个线程，当数组被填满时， thread1在数组中放置一个整数， thread2从数组中获取整数。请注意，为了使线程2工作，它需要知道数组的状态，无论线程1是否已将其填满。

实施Runnable使您可以灵活地共享对象，而extends Thread使您可以为每个线程创建新对象，因此，由thread1完成的所有更新都将丢失到thread2中。

#21楼

如果我没有记错，它或多或少类似于

接口和抽象类之间有什么区别？

扩展建立“ 是 ”关系并提供“ 具有 ”功能。

首选实现Runnable ：

如果您不必扩展Thread类并修改Thread API的默认实现
如果您正在执行即发即弃命令
如果您已经在扩展另一堂课

首选“ 扩展线程 ”：

如果您必须覆盖oracle文档页面中列出的所有这些Thread方法

通常，您不需要重写线程行为。因此，在大多数情况下，首选使用Runnable工具 。

另外，使用高级ExecutorService或ThreadPoolExecutorService API可提供更大的灵活性和控制力。

看看这个SE问题：

ExecutorService与休闲线程Spanner

#22楼

我会说还有第三种方式：

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

也许这受我最近大量使用Javascript和Actionscript 3的影响，但是通过这种方式，您的类不需要实现像Runnable这样的模糊接口。

#23楼

扩展线程和实现Runnable之间的区别是：

#24楼

我不是专家，但是我可以想到一个实现Runnable而不是扩展线程的原因：Java仅支持单继承，因此您只能扩展一个类。

编辑：最初说“实现接口需要更少的资源”。同样，但是您需要以任何一种方式创建一个新的Thread实例，所以这是错误的。

#25楼

是的：IMO是实现Runnable的首选方法。您并不是真的专门研究线程的行为。您只是在给它一些东西来运行。这意味着合成是从哲学上讲“更纯净”的方式。

实际上 ，这意味着您可以实现Runnable并从另一个类进行扩展。

#26楼

实例化一个接口可以使您的代码与线程实现之间的分隔更加清晰，因此在这种情况下，我更喜欢实现Runnable。

#27楼

tl; dr：实现Runnable更好。 但是，警告很重要

通常，我建议使用类似Runnable而不是Thread因为它可以使您的工作与并发选择保持松散的联系。例如，如果您使用Runnable并在以后决定实际上不需要它自己的Thread ，则可以只调用threadA.run（）。

警告：在这里，我强烈建议不要使用原始线程。我更喜欢使用Callables和FutureTasks （来自javadoc：“可取消的异步计算”）。与大量原始线程相比，超时的集成，适当的取消以及现代并发支持的线程池对我来说都更加有用。

后续：有一个FutureTask构造函数，可让您使用Runnables（如果您对此最满意），并且仍可从现代并发工具中受益。引用javadoc ：

如果不需要特定的结果，请考虑使用以下形式的构造：

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

因此，如果我们将它们的runnable替换为您的threadA ， threadA得到以下信息：

new FutureTask<Object>(threadA, null)

允许您更接近Runnables的另一个选项是ThreadPoolExecutor 。您可以使用execute方法传入Runnable以执行“将来某个时间执行给定的任务”。

如果您想尝试使用线程池，则上面的代码片段将变为以下内容（使用Executors.newCachedThreadPool（）工厂方法）：

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

#28楼

您应该实现Runnable，但是如果您在Java 5或更高版本上运行，则不应使用new Thread启动它，而应使用ExecutorService 。有关详细信息，请参见：如何在Java中实现简单线程。

#29楼

尚未引起我惊讶的一件事是实现Runnable使您的类更加灵活。

如果扩展线程，那么您正在执行的操作将始终处于线程中。但是，如果您实现Runnable ，则不必如此。您可以在线程中运行它，或将其传递给某种执行服务，或者仅作为任务在单个线程应用程序中传递（可能在以后的时间，但在同一线程中运行）。如果您仅使用Runnable ，则这些选项比将自己绑定到Thread要开放得多。

#30楼

是的，如果您调用ThreadA call，则无需调用start方法，而仅在调用ThreadA类之后才调用run方法。但是如果使用ThreadB调用，则需要为调用run方法启动线程。如果您还有其他帮助，请回复我。