从我在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
这两个代码块有什么显著的区别吗？
当前回答
您希望实现接口而不是扩展基类的一个原因是您已经在扩展其他类。您只能扩展一个类，但可以实现任意数量的接口。
如果扩展Thread，基本上就是防止逻辑被除“this”之外的任何其他线程执行。如果您只希望一些线程执行您的逻辑，那么最好只实现Runnable。
其他回答
我不是专家，但我能想到实现Runnable而不是扩展Thread的一个原因：Java只支持单一继承，因此只能扩展一个类。
编辑：这原本是说“实现一个接口需要更少的资源”，但无论如何都需要创建一个新的线程实例，所以这是错误的。
可运行，因为：
为可运行的实现以扩展另一类将代码与处决允许您运行可从线程池运行事件线程，或以任何其他方式未来。
即使你现在不需要这些，你将来也可以。由于重写线程没有好处，Runnable是一个更好的解决方案。
1.扩展线程接口，就像让类只作为线程一样。您的新类将像一个增强的线程。
jshell> public class Test extends Thread{
...> public Test(String name){
...> super(name);
...> }
...> public void run(){
...> System.out.println(Thread.currentThread().getName());
...> }
...> }
| created class Test
jshell> Test t1=new Test("MyThread");
t1 ==> Thread[MyThread,5,main]
它创建一个线程，而不是Test对象。所以它会像一个线程。不能在线程之间共享Test类的实例。
2.实现可运行接口。
jshell> public class Test1 implements Runnable{
...> public void run(){
...> System.out.println(Thread.currentThread().getName());
...> }
...> public String getName(){
...> return "testing";}
...> }
| created class Test1
jshell> Test1 t1=new Test1();
t1 ==> Test1@396a51ab --> this creates Test1 object.
该对象可以通过以下方式跨线程共享，
jshell> Thread t1=new Thread(t1,"Hai");
t ==> Thread[Hai,5,main]
jshell> Thread t=new Thread(t1,"Hai");
t ==> Thread[Hai,5,main]
我认为已经有很多关于这个话题的讨论，认为这可能对基础知识有所帮助。
对于大多数工作线程来说，最好的方法是将线程完全封装在工作线程类中，这样就不会有任何外部干扰，导致不需要的和无效的线程/类状态。
我刚刚发布了一个示例，因此我也将与您分享：
/**
* 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();
}
}
如果我没有错的话，它或多或少类似于
接口和抽象类之间的区别是什么？
extends建立“Is A”关系，接口提供“Has A”功能。
首选工具可运行：
如果不需要扩展Thread类并修改Thread API默认实现如果你执行的是一个火灾和忘记命令如果您已经在扩展另一个类
首选“扩展线程”：
如果必须重写oracle文档页中列出的任何线程方法
通常，您不需要重写线程行为。因此，在大多数情况下，首选实现Runnable。
另一方面，使用高级ExecutorService或ThreadPoolExecutorServiceAPI提供了更多的灵活性和控制。
看看这个SE问题：
ExecutorService vs休闲线程生成器
