从我在Java中使用线程的时间来看，我发现了两种编写线程的方法：
使用可运行的机具：
public class MyRunnable implements Runnable {
public void run() {
//Code
}
}
//Started with a "new Thread(new MyRunnable()).start()" call
或者，使用扩展线程：
public class MyThread extends Thread {
public MyThread() {
super("MyThread");
}
public void run() {
//Code
}
}
//Started with a "new MyThread().start()" call
这两个代码块有什么显著的区别吗？
当前回答
由于这是一个非常流行的话题，而且好的答案到处都是，而且处理得非常深入，所以我觉得将其他人的好答案汇编成更简洁的形式是合理的，因此新来者可以很容易地概括：
通常扩展类以添加或修改功能。因此，如果不想覆盖任何线程行为，请使用Runnable。同样，如果不需要继承线程方法，那么可以通过使用Runnable来避免这种开销。单一继承：如果您扩展Thread，则不能从任何其他类扩展，因此如果这是您需要做的，则必须使用Runnable。将领域逻辑与技术手段分开是一个很好的设计，从这个意义上说，最好有一个可运行的任务将您的任务与运行者隔离开来。您可以多次执行同一个Runnable对象，但Thread对象只能启动一次。（也许是执行器接受Runnables而不接受Threads的原因。）如果您将任务开发为Runnable，那么您现在和将来都可以灵活使用它。您可以通过执行器同时运行，也可以通过线程运行。您还可以在同一线程中非并发地使用/调用它，就像其他任何普通类型/对象一样。这也使得在单元测试中分离任务逻辑和并发方面更加容易。如果你对这个问题感兴趣，你可能也会对Callable和Runnable之间的区别感兴趣。
其他回答
您应该实现Runnable，但如果您在Java5或更高版本上运行，则不应该使用新线程启动它，而是使用ExecutorService。有关详细信息，请参阅：如何在Java中实现简单线程。
在极少数情况下，您只运行一次，应该因为DRY而扩展Thread。如果多次调用它，则应实现Runnable，因为不应重新启动同一线程。
如果使用runnable，则可以节省空间以扩展到任何其他类。
对于大多数工作线程来说，最好的方法是将线程完全封装在工作线程类中，这样就不会有任何外部干扰，导致不需要的和无效的线程/类状态。
我刚刚发布了一个示例，因此我也将与您分享：
/**
* This worker can only run once
* @author JayC667
*/
public class ProperThreading {
private final Thread mThread = new Thread(() -> runWorkingLoop()); // if you want worker to be able to run multiple times, move initialisation into startThread()
private volatile boolean mThreadStarted = false;
private volatile boolean mStopRequested = false;
private final long mLoopSleepTime;
public ProperThreading(final long pLoopSleepTime /* pass more arguments here, store in members */ ) {
mLoopSleepTime = pLoopSleepTime;
}
public synchronized void startThread() {
if (mThreadStarted) throw new IllegalStateException("Worker Thread may only be started once and is already running!");
mThreadStarted = true;
mThread.start();
}
private void runWorkingLoop() {
while (!mStopRequested /* && other checks */ ) {
try {
// do the magic work here
Thread.sleep(mLoopSleepTime);
} catch (final InterruptedException e) {
break;
} catch (final Exception e) {
// do at least some basic handling here, you should NEVER ignore exception unless you know exactly what you're doing, and then it should be commented!
}
}
}
public synchronized void stopThread() {
if (!mThreadStarted) throw new IllegalStateException("Worker Thread is not even running yet!");
mStopRequested = true;
mThread.interrupt();
}
}
tl；dr:implements Runnable更好。然而，警告很重要。
一般来说，我建议使用Runnable而不是Thread这样的工具，因为它允许您保持工作与并发选择之间的松散耦合。例如，如果您使用了一个Runnable，并且稍后决定它实际上不需要自己的Thread，那么您可以调用threadA.run（）。
注意：在这里，我强烈反对使用原始线程。我更喜欢使用Callables和FutureTasks（来自javadoc：“可取消的异步计算”）。现代并发支持的超时、适当取消和线程池的集成对我来说都比成堆的原始线程有用得多。
后续：有一个FutureTask构造函数，它允许您使用Runnables（如果这是您最熟悉的），并且仍然可以获得现代并发工具的好处。引用javadoc：
如果不需要特定的结果，请考虑使用以下形式的构造：
Future<?> f = new FutureTask<Object>(runnable, null)
因此，如果我们用threadA替换它们的runable，我们会得到以下结果：
new FutureTask<Object>(threadA, null)
另一个让您更接近Runnables的选项是ThreadPoolExecutor。您可以使用execute方法传入Runnable以执行“将来某个时候的给定任务”。
如果您想尝试使用线程池，上面的代码片段将变成如下（使用Executors.newCachedThreadPool（）工厂方法）：
ExecutorService es = Executors.newCachedThreadPool();
es.execute(new ThreadA());
